diff --git a/.gitlab/ci/build.yml b/.gitlab/ci/build.yml
index 5059dd487681e37f747e46a25dbfbcf6f6927623..0a5d2fc80b4427f04019f0e06bf8de82f0c419b8 100644
--- a/.gitlab/ci/build.yml
+++ b/.gitlab/ci/build.yml
@@ -18,7 +18,7 @@
     - diff poetry.lock /home/tezos/poetry.lock
     - diff pyproject.toml /home/tezos/pyproject.toml
     # 2. Actually build
-    - make all build-sandbox build-unreleased
+    - make all build-unreleased
     # 3. Also build the tps evaluation tool which is not part of the default build.
     #    NOTE: We add $COVERAGE_OPTIONS to all dune build commands to enable reuse of
     #    build artifacts.
diff --git a/.gitlab/ci/templates.yml b/.gitlab/ci/templates.yml
index 92b02ce1686a30ab74f5f81f4f3f0d776dcb3975..b5c0e61b4fb0197c54e53a98c97972370ebb9d7d 100644
--- a/.gitlab/ci/templates.yml
+++ b/.gitlab/ci/templates.yml
@@ -2,7 +2,7 @@ variables:
   # /!\ CI_REGISTRY is overriden to use a private Docker registry mirror in AWS ECR
   # in GitLab namespaces `nomadic-labs` and `tezos`
   ## This value MUST be the same as `opam_repository_tag` in `scripts/version.sh`
-  build_deps_image_version: 98a3fd9095e9008f5f687266da8faf798db2240c
+  build_deps_image_version: 7b619e8f294911d4ee5930b3eb5c334dcf710e65
   build_deps_image_name: "${CI_REGISTRY}/tezos/opam-repository"
   GIT_STRATEGY: fetch
   GIT_DEPTH: "1"
diff --git a/.gitlab/ci/test/integration.yml b/.gitlab/ci/test/integration.yml
index 3445203f1e36a209d31473a35588bb30b34f803f..14480248fc8a997b23d22efb005e8fab22e3b58a 100644
--- a/.gitlab/ci/test/integration.yml
+++ b/.gitlab/ci/test/integration.yml
@@ -1,11 +1,6 @@
-# integration:proto:sandbox and integration:compiler-rejections do not
+# integration:compiler-rejections does not
 # require access to the binaries like the "true" integration tests
-# below. Therefore, they do not extend the .integration_template.
-
-integration:proto:sandbox:
-  extends: .test_template
-  script:
-    - dune build @runtest_sandbox
+# below. Therefore, it does not extend the .integration_template.
 
 integration:compiler-rejections:
   extends: .test_template
@@ -60,21 +55,6 @@ script:test_release_versions:
     - sudo chown -R $(id -u):$(id -g) $CI_PROJECT_DIR
     - ./scripts/test_release_version.sh
 
-############################################################
-## Stage: run OCaml integration tests                     ##
-############################################################
-
-integration:sandboxes:acc-endorsement:
-  extends: .integration_template
-  script:
-    - TMP=$PWD make -f sandbox.Makefile accusations_simple_double_endorsing
-  artifacts:
-    paths:
-      - flextesa-acc-sde
-      - $BISECT_FILE
-    expire_in: 1 day
-    when: always
-
 ############################################################
 ## Stage: run python integration tests                    ##
 ############################################################
@@ -84,10 +64,10 @@ integration:sandboxes:acc-endorsement:
 .pytest_template:
   extends:
     - .test_template
-  needs:
-    - build_x86_64
-  dependencies:
-    - build_x86_64
+  dependencies: ["build_x86_64"]
+  # Start immediately after 'build_x86_64' and don't wait for
+  # intermediate stages to succeed
+  needs: ["build_x86_64"]
   before_script:
     # Load the environment poetry previously created in the docker image.
     # Give access to the Python dependencies/executables
diff --git a/.gitlab/ci/test/templates.yml b/.gitlab/ci/test/templates.yml
index 3f3fa12e995dbb66790d2d2ef309a628ccc499a5..66b0219baf2b59851fee33f7d5a30e17477de42d 100644
--- a/.gitlab/ci/test/templates.yml
+++ b/.gitlab/ci/test/templates.yml
@@ -25,7 +25,7 @@
     - .template__coverage_files
   dependencies: ["build_x86_64"]
   # Start immediately after 'build_x86_64' and don't wait for
-  # intermediate stages to succeeds
+  # intermediate stages to succeed
   needs: ["build_x86_64"]
   before_script:
-    - if [ ! -f tezos-node ] || [ ! -f tezos-client ] || [ ! -f tezos-codec ] || [ ! -f tezos-sandbox ]; then make all build-unreleased; fi
+    - if [ ! -f tezos-node ] || [ ! -f tezos-client ] || [ ! -f tezos-codec ]; then make all build-unreleased; fi
diff --git a/.gitlab/ci/test/tezt.yml b/.gitlab/ci/test/tezt.yml
index be9efdc212c8636e2eb2fec6f42ab47dea068b18..6becf1c068cbf9e063febae566b683450fbf22ff 100644
--- a/.gitlab/ci/test/tezt.yml
+++ b/.gitlab/ci/test/tezt.yml
@@ -73,7 +73,7 @@ tezt:self_tests:
 #    - cat mainnet.roll.* | xz -d -v -T0 > mainnet.rolling
 #    - scripts/prepare_migration_test.sh auto mainnet.rolling "$block_hash"
 #  script:
-#    - if [ ! -f tezos-node ] || [ ! -f tezos-client ] || [ ! -f tezos-codec ] || [ ! -f tezos-sandbox ]; then make; fi
+#    - if [ ! -f tezos-node ] || [ ! -f tezos-client ] || [ ! -f tezos-codec ] ; then make; fi
 #    - dune exec ./tezt/manual_tests/main.exe -- migration --color --log-buffer-size 5000 --log-file tezt-migration.log
 #  artifacts:
 #    when: always
diff --git a/.gitlab/ci/test_coverage.yml b/.gitlab/ci/test_coverage.yml
index ca4b28ebcd3dbc6963f6af2b237702cba5d08aa5..478de6e1fcd506ad82049f9a510d5a35469589cf 100644
--- a/.gitlab/ci/test_coverage.yml
+++ b/.gitlab/ci/test_coverage.yml
@@ -20,7 +20,6 @@ unified_coverage:
     - "integration:pytest 7/9"
     - "integration:pytest 8/9"
     - "integration:pytest 9/9"
-    - "integration:sandboxes:acc-endorsement"
     - "test-liquidity-baking-scripts"
     - "tezt 1/9"
     - "tezt 2/9"
diff --git a/Makefile b/Makefile
index 38f592492d50fdfae43fb1ffb6cfa1be5e029b7c..4c606b0c68a39d79dfb400230b179b3787bd8bb7 100644
--- a/Makefile
+++ b/Makefile
@@ -137,11 +137,6 @@ coverage-report-cobertura:
 enable-time-measurement:
 	@$(MAKE) build PROFILE=dev DUNE_INSTRUMENT_WITH=tezos-time-measurement
 
-.PHONY: build-sandbox
-build-sandbox:
-	@dune build --profile=$(PROFILE) $(COVERAGE_OPTIONS) src/bin_sandbox/main.exe
-	@cp -f _build/default/src/bin_sandbox/main.exe tezos-sandbox
-
 .PHONY: test-protocol-compile
 test-protocol-compile:
 	@dune build --profile=$(PROFILE) $(COVERAGE_OPTIONS) @runtest_compile_protocol
@@ -185,10 +180,6 @@ test-python-alpha: all
 test-python-tenderbake: all
 	@$(MAKE) -C tests_python tenderbake
 
-.PHONY: test-flextesa
-test-flextesa:
-	@$(MAKE) -f sandbox.Makefile
-
 # TODO: https://gitlab.com/tezos/tezos/-/issues/3018
 # Disable verbose once the log file bug in Alcotest is fixed.
 .PHONY: test-js
@@ -214,11 +205,11 @@ test-tezt-coverage:
 	@dune exec --profile=$(PROFILE) $(COVERAGE_OPTIONS) tezt/tests/main.exe -- --keep-going --test-timeout 1800
 
 .PHONY: test-code
-test-code: test-protocol-compile test-unit test-flextesa test-python test-tezt
+test-code: test-protocol-compile test-unit test-python test-tezt
 
-# This is `make test-code` except for flextesa (which doesn't
-# play well with coverage). We allow failure (prefix "-") because we still want
-# the coverage report even if an individual test happens to fail.
+# This is as `make test-code` except we allow failure (prefix "-")
+# because we still want the coverage report even if an individual
+# test happens to fail.
 .PHONY: test-coverage
 test-coverage:
 	-@$(MAKE) test-protocol-compile
@@ -394,7 +385,7 @@ coverage-clean:
 .PHONY: clean
 clean: coverage-clean
 	@-dune clean
-	@-rm -f ${TEZOS_BIN} ${UNRELEASED_TEZOS_BIN} tezos-sandbox
+	@-rm -f ${TEZOS_BIN} ${UNRELEASED_TEZOS_BIN}
 	@-${MAKE} -C docs clean
 	@-${MAKE} -C tests_python clean
 	@-rm -f docs/api/tezos-{baker,endorser,accuser}-alpha.html docs/api/tezos-{admin-,}client.html docs/api/tezos-signer.html
diff --git a/docs/developer/contributing.rst b/docs/developer/contributing.rst
index e8da5bc5d7e3a745d33e64d0b32c2f8451d0fcf5..b9e8483fecfdaeaa698bdb4534b04dfd42c70d8a 100644
--- a/docs/developer/contributing.rst
+++ b/docs/developer/contributing.rst
@@ -324,7 +324,6 @@ any subitems represent the longer description of that commit)::
 
   * Doc: mark bug #13 as fixed
   * Test_python: add test for p2p bug #13
-  * Flextesa: add test for p2p bug #13
   * Shell: fix p2p bug #13
     - fix bug in the shell
     - fix relative unit test
diff --git a/docs/developer/flextesa.rst b/docs/developer/flextesa.rst
deleted file mode 100644
index efc0e593f556da98129fe806030544cef55dbdb8..0000000000000000000000000000000000000000
--- a/docs/developer/flextesa.rst
+++ /dev/null
@@ -1,289 +0,0 @@
-Flexible Network Sandboxes
-==========================
-
-The binary ``tezos-sandbox`` uses the Flextesa library to provide
-sandbox networks with baker and endorser daemons, with various test
-scenarios.
-
-Some of those scenarios run in the CI, see ``./src/bin_sandbox/dune`` (although
-it is not recommended to experiment with sandboxes using ``dune`` which can
-leave unkilled processes easily, see issue
-`#2445 <https://github.com/ocaml/dune/issues/2445>`__).
-
-
-Build
------
-
-The application is not built by default, one needs:
-
-::
-
-    make build-sandbox
-
-Usage
------
-
-See ``./tezos-sandbox --help`` and all the examples below.
-
-When running (semi-)interactive tests, it is recommended to wrap the
-call with ``rlwrap`` or ``ledit``.
-
-MacOSX Users
-------------
-
-At runtime, sandboxes usually depend on a couple of linux utilities.
-
-If you are on Mac OS X, you can do ``brew install coreutils util-linux``. Then run
-the tests with:
-
-::
-
-    export PATH="/usr/local/opt/coreutils/libexec/gnubin:/usr/local/opt/util-linux/bin:$PATH"
-
-
-See Also
---------
-
-``tezos-sandbox`` based on the Flextesa library which is being developed
-at `gitlab.com/tezos/flextesa <https://gitlab.com/tezos/flextesa>`__.
-One can find more instructions there, including how to use isolated
-sandboxes using Docker. TQ Tezos' assets portal also shows how to start
-a sandbox and interact with it using a separate ``tezos-client``:
-https://assets.tqtezos.com/docs/setup/2-sandbox/.
-
-
-Concepts
---------
-
-Let’s clear a couple of things up:
-
--  *full* Vs *manual* sandbox: we call “full” a sandbox that uses
-   baker/endorser/accuser daemons and hence advances by itself. A
-   “manual” sandbox only has nodes, they require successive calls to
-   ``bake for`` tezos-client commands (or ``bake`` in the interactive
-   prompt if any).
--  Each sandbox scenario has a *root path* where all logs and generated
-   files go (usually exposed with the ``--root-path`` option).
--  Some sandboxes can start an interactive command-line interface. The
-   command-line parsing uses the Sexplib library; see
-   https://github.com/janestreet/sexplib#about for the lexical
-   conventions. Try the ``help`` command for instance.
--  By default, sandboxed nodes get assigned successive port numbers for
-   their RPC and P2P services; with the option ``--base-port PORT``,
-   ``PORT`` will be used for the RPC of node 0, ``PORT + 1`` for its
-   P2P, ``PORT + 2`` for the RPC of node 1, etc.
--  Sandboxes like the ``mini-network`` also provide a shell-environment
-   file at ``$ROOT_PATH/shell.env`` which provides aliases to
-   ``tezos-client`` commands compatible with the sandbox (see also
-   the ``help-env`` interactive command).
-
-
-Examples
---------
-
-Interactive Mini-Network
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-One can run a mini-network advancing fast with accusers, bakers, and
-endorsers:
-
-::
-
-    rlwrap ./tezos-sandbox mini-network \
-           --root-path /tmp/zz-mininet-test \
-           --size 2 \
-           --number-of-bootstrap-accounts 2 \
-           --tezos-node-binary ./tezos-node \
-           --tezos-baker-alpha-binary ./tezos-baker-alpha \
-           --tezos-accuser-alpha-binary ./tezos-accuser-alpha \
-           --tezos-client-binary ./tezos-client
-
-Once the network is started this test scenario becomes interactive:
-
-::
-
-    Flextesa.mininet: Please enter command:
-
-Just try ``h`` (or ``help``) to see the available commands, or ``q`` to kill the
-sandbox and quit.
-
-The ``mini-network`` has many options, ``./tezos-sandbox mini --help``.
-
-Mini-Network with User Activated Upgrade
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-This example runs another full sandbox (3 nodes, 2 “bakers”), for a
-limited amount of time (60 blocks, no interactivity), and performs a
-user-activated-upgrade (a.k.a. a protocol “hard-fork”) between Babylon
-and Carthage (as built on the ``master`` branch).
-
-We also set the base-port to 3000 and add some random traffic;
-i.e. create contract originations and contract calls (for now the
-setting also requires also the ``--until-level`` option):
-
-::
-
-   ./tezos-sandbox mini-network \
-          --root-path /tmp/hard-fork-mininet \
-          --size 3 \
-          --base-port 3_000 \
-          --number-of-bootstrap-accounts 2 \
-          --protocol-hash PsBabyM1eUXZseaJdmXFApDSBqj8YBfwELoxZHHW77EMcAbbwAS \
-          --protocol-kind Babylon \
-          --until-level 60 \
-          --random-traffic any \
-          --tezos-baker-alpha-binary ./tezos-baker-005-PsBabyM1 \
-          --tezos-endorser-alpha-binary ./tezos-endorser-005-PsBabyM1 \
-          --tezos-accuser-alpha-binary ./tezos-accuser-005-PsBabyM1 \
-          --hard-fork 20:PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb \
-          --hard-fork-baker-alpha-binary ./tezos-baker-006-PsCARTHA \
-          --hard-fork-endorser-alpha-binary ./tezos-endorser-006-PsCARTHA \
-          --hard-fork-accuser-alpha-binary ./tezos-accuser-006-PsCARTHA \
-          --tezos-node-binary ./tezos-node \
-          --tezos-client-binary ./tezos-client
-
-
-Manual Mini-Network With An Archive Node
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-An interactive Carthage sandbox with 3 nodes, one of which running in
-``archive`` mode, and no baking daemons:
-
-::
-
-   rlwrap ./tezos-sandbox mini-network \
-          --root-path /tmp/manual-mininet \
-          --size 3 \
-          --set-history-mode N000:archive \
-          --no-baking \
-          --protocol-hash PsCARTHAGazKbHtnKfLzQg3kms52kSRpgnDY982a9oYsSXRLQEb \
-          --protocol-kind Carthage \
-          --tezos-baker-alpha-binary ./tezos-baker-006-PsCARTHA \
-          --tezos-endorser-alpha-binary ./tezos-endorser-006-PsCARTHA \
-          --tezos-accuser-alpha-binary ./tezos-accuser-006-PsCARTHA \
-          --tezos-node-binary ./tezos-node \
-          --tezos-client-binary ./tezos-client
-
-Once the network is started, we enter the interactive mode, and we can
-use the ``bake`` command to create blocks (``bake`` can take an
-argument: which client to bake with, e.g. \ ``bake 2``).
-
-We can check that ``N000`` is indeed an archive node:
-``c2 rpc get /chains/main/checkpoint`` (``help`` tells us that ``c2`` is
-the client for the node ``N000``).
-
-Double Endorsement Accusation
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-There are 3 “accusation scenarios” so far, see
-``./tezos-sandbox accusation --help``. For instance, the following command
-starts a small 3-node network, forces one baker to endorse two
-concurrent branches, and then makes another baker inject (and bake) the
-double-endorsement-evidence operation. The option ``--pause-at-end=true`` tells
-``tezos-sandbox`` to enter the interactive mode (command prompt) at the end of
-the test to give a chance to explore the sandbox before killing all the nodes.
-
-::
-
-    PATH=.:$PATH rlwrap ./tezos-sandbox accusations simple-double-endorsing \
-         --root $PWD/double-endorsing-test \
-         --pause-at-end=true
-
-
-Voting With a Ledger Nano Device
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The voting test tries to do a full round of voting and protocol switch,
-including baking on the test-chain, see documentation in
-``./tezos-sandbox voting --help``.
-
-The test can run in a simpler-to-setup, or “degraded,” mode of operation
-(cf. call in ``./src/bin_flextesa/dune`` for the version which
-run in Gitlab-CI pipelines). In this example, we run instead a full test
-with a Ledger Nano device as one of the bakers/voters. The test automatically
-becomes **interactive** because the user has to press buttons on the
-device, including for changing between apps.
-
-Get an URI for your ledger (the test requires both the Wallet and
-Baking apps):
-
-::
-
-    tezos-client list connected ledgers
-
-And use the URI (no need to import it) for the ``--with-ledger`` option:
-
-::
-
-    rlwrap ./tezos-sandbox voting \
-         ./src/proto_006_PsCARTHA/lib_protocol/TEZOS_PROTOCOL \
-         ./src/proto_demo_noops/lib_protocol/TEZOS_PROTOCOL \
-         --with-ledger "ledger://crouching-tiger-hidden-dragon/ed25519/0'/0'" \
-         --serialize-proposals \
-         --base-port=20_000 \
-         --current-node-binary ./tezos-node \
-         --current-client-binary ./tezos-client \
-         --winner-client-binary ./tezos-client \
-         --current-admin-client-binary ./tezos-admin-client \
-         --pause-on-error=true
-
--  The first path argument has to be the path to a valid protocol which
-   can be switched to from the current (``proto_alpha``) one.
--  The second protocol, the looser, only needs to be valid for the
-   protocol compilation.
--  The option ``--serialize-proposals`` tells the test to call
-   ``tezos-client submit proposals for ...`` one proposal at a time
-   which is the only method the ledger Wallet app can really understand.
--  The ``*-binary`` options allow to set the paths to the executables
-   for the different protocols: ``current`` and ``winner``.
-
-The test becomes interactive and guides you through the interactions
-with the ledger, e.g.:
-
-::
-
-   Flextesa.voting:
-     Ledger-prompt
-
-         Setting up "ledger://crouching-tiger-hidden-dragon/ed25519/0'/0'" for
-         baking. The ledger should be showing the setup parameters (Address,
-         Main chain, HWMs).
-
-        Please hit “✔” on the ledger.
-
-Implementation Considerations
------------------------------
-
-``Running_processes`` is very high-level (actually agnostic to Tezos).
-Most processes are actually calls to ``sh -c <script>`` where
-``<script>`` is the result of a ``Genspio`` compilation, this leaves the
-option to later easily run some processes over SSH (without OCaml
-dependencies on the destination host) or in special containers (e.g.
-``docker run --cpu-shares ...``).
-
-The prompt commands for interactive use use ``Base.Sexp.t`` parsers
-(because already a dependency, and we need a good string literal parser
-so we cannot use ``Clic`` nor ``Cmdliner``).
-
-Special Coding Style
---------------------
-
-A fresh “just for testing project” is a good occasion to experiment a
-bit …
-
-See ``./vendor/lib_flextesa/internal_pervasives.ml``:
-
--  ``EF``: we try to use combinators on top of
-   `Easy-format <https://mjambon.github.io/mjambon2016/easy-format.html>`__
-   for most pretty-printing (it is still compatible with ``Format`` but
-   it is much more functional/composable and does not rely on
-   ``@[<2,3>@{crazy}@ @<acronym>EDSLs@n@]``).
--  Many standard modules are taken from Jane St Base (already a
-   dependency of Tezos): List, String, Option, Int, Float.
--  Error monad uses *more typed* errors (polymorphic variants),
-   cf. module ``Asynchronous_result`` (and note that ``bind`` also calls
-   ``Lwt_unix.auto_yield 0.005 ()``).
--  All state is kept in a (*non-global*) value passed as argument
-   everywhere needed. To simplify the dependency management the state
-   variables are objects (cf. ``Base_state``, then ``Paths``,
-   ``Console``, etc).
diff --git a/docs/developer/testing.rst b/docs/developer/testing.rst
index 15c12234011e78b40467ff592ea145b1e7a657cb..f57889e47ecf9bae530553eb1cde82b5e33fac49 100644
--- a/docs/developer/testing.rst
+++ b/docs/developer/testing.rst
@@ -78,16 +78,16 @@ in more detail.
 
 
 .. csv-table:: Testing frameworks and their applications in Tezos. PT:
-               :ref:`Python testing and execution framework <pytest_section>`, EXP: :ref:`ppx_expect_section`, AT: :ref:`alcotest_section`, PBT: :ref:`property_based_test`, FT: :ref:`flextesa_section`, TZ: :ref:`tezt_section`
+               :ref:`Python testing and execution framework <pytest_section>`, EXP: :ref:`ppx_expect_section`, AT: :ref:`alcotest_section`, PBT: :ref:`property_based_test`, TZ: :ref:`tezt_section`
    :header: "Component","Unit","Property","Integration","System","Regression"
 
-   "Node",":ref:`AT <alcotest_section>`",":ref:`PBT <property_based_test>`",":ref:`AT <alcotest_section>`",":ref:`PT <pytest_section>`, :ref:`FT <flextesa_section>`, :ref:`TZ <tezt_section>`"
+   "Node",":ref:`AT <alcotest_section>`",":ref:`PBT <property_based_test>`",":ref:`AT <alcotest_section>`",":ref:`PT <pytest_section>`, :ref:`TZ <tezt_section>`"
    "-- Protocol",":ref:`AT <alcotest_section>`, :ref:`EXP <ppx_expect_section>`",":ref:`PBT <property_based_test>`",""
    "-- -- Michelson interpreter",":ref:`AT <alcotest_section>`","","",":ref:`PT <pytest_section>`",":ref:`PT <pytest_section>`"
-   "Client",":ref:`EXP <ppx_expect_section>`",":ref:`PBT <property_based_test>`","",":ref:`PT <pytest_section>`, :ref:`FT <flextesa_section>`, :ref:`TZ <tezt_section>`"
-   "Networked nodes","--","",":ref:`PT <pytest_section>`, :ref:`FT <flextesa_section>`","", ""
-   "Endorser","","","",":ref:`FT <flextesa_section>`"
-   "Baker","","","",":ref:`FT <flextesa_section>`"
+   "Client",":ref:`EXP <ppx_expect_section>`",":ref:`PBT <property_based_test>`","",":ref:`PT <pytest_section>`, :ref:`TZ <tezt_section>`"
+   "Networked nodes","--","",":ref:`PT <pytest_section>`","", ""
+   "Endorser","","","",""
+   "Baker","","","",""
 
 
 Testing frameworks
@@ -218,40 +218,13 @@ References:
  - `pytest-regtest pip package <https://pypi.org/project/pytest-regtest/>`_
  - :ref:`Section in Tezos Developer Documentation on pytest-regtest <pytest_regression_testing>`
 
-.. _flextesa_section:
-
-Flextesa
-~~~~~~~~
-
-Flextesa (Flexible Test Sandboxes) is an OCaml library for setting up
-configurable and scriptable sandboxes to meet specific testing
-needs. Flextesa can also be used for interactive tests. This is used,
-for instance, in some tests that require the user to interact with the
-Ledger application.
-
-Typical use cases:
- - In terms of use cases, Flextesa is similar to the :ref:`Python testing
-   and execution framework <pytest_section>`.
-
-Example test:
- - Testing double baking, accusations and double-baking accusation
-   scenarios (in :src:`src/bin_sandbox/command_accusations.ml`)
-
-References:
- - :doc:`Section in Tezos Developer Documentation on Flextesa <flextesa>`
- - `Blog post introducing Flextesa
-   <https://medium.com/@obsidian.systems/introducing-flextesa-robust-testing-tools-for-tezos-and-its-applications-edc1e336a209>`_
- - `GitLab repository <https://gitlab.com/tezos/flextesa>`_
- - `An example setting up a Babylon docker sandbox <https://assets.tqtezos.com/docs/setup/2-sandbox/>`_
- - `API documentation <https://tezos.gitlab.io/flextesa/lib-index.html>`_
-
 .. _tezt_section:
 
 Tezt
 ~~~~
 
 :doc:`Tezt <tezt>` is a system testing framework for Tezos. It is
-intended as a replacement to Flextesa and as an OCaml-based alternative
+intended as a replacement to `Flextesa <https://tezos.gitlab.io/flextesa/>`_ and as an OCaml-based alternative
 to :ref:`Python testing and execution framework
 <pytest_section>`. Like the latter, Tezt is also capable of regression
 testing. Tezt focuses on tests that run in the CI, although it is also
@@ -264,16 +237,14 @@ the Tezos binaries: the client, baker, etc.
 
 Typical use cases:
  - In terms of use cases, Tezt is similar to the :ref:`Python testing and
-   execution framework <pytest_section>` and :ref:`Flextesa
-   <flextesa_section>`. It can be used by authors that prefer OCaml
+   execution framework <pytest_section>` and `Flextesa <https://tezos.gitlab.io/flextesa/>`_.
+   It can be used by authors that prefer OCaml
    for writing system tests.
 
 Example tests:
  - Testing baking (in :src:`tezt/tests/basic.ml`)
  - Testing double baking and double endorsement scenarios (in
-   :src:`tezt/tests/double_bake.ml`). This test is a rewrite of the
-   Flextesa double baking scenario mentioned above, that demonstrates
-   the difference between the two frameworks.
+   :src:`tezt/tests/double_bake.ml`).
  - Testing absence of regressions in encodings (in :src:`tezt/tests/encoding.ml`)
 
 References:
@@ -410,7 +381,7 @@ developer utilities and old protocols. In particular:
 
  - benchmarks, e.g. ``src/lib_shell/bench/dune``
  - bindings, e.g. ``src/lib_sapling/bindings/dune``
- - test frameworks, e.g. ``src/bin_sandbox/dune``
+ - test frameworks, e.g. ``tezt/lib/dune``
  - test packages, e.g. ``src/*/test/dune``
  - old protocols, e.g. ``src/proto_00*/*/*dune``
  - helper utilities, e.g.:
@@ -555,9 +526,6 @@ The OCaml package tests (Alcotest & QCheck)
    one job per protocol package, in addition to one job regrouping
    tests for remaining packages.
 
-Flextesa
-   Flextesa tests run in one job per test.
-
 Adding tests to the CI
 ~~~~~~~~~~~~~~~~~~~~~~
 
@@ -592,7 +560,7 @@ The OCaml package tests (Alcotest & QCheck)
   ``src/proto_XXX_YYYYYYYY/lib_\*.test_proto`` to the ``unit:XXX_YYYYYYYY``
   ``make`` invocation.
 
-Other (including Flextesa)
+Other
   For other types of tests, you need to manually modify the
   :src:`.gitlab-ci.yml`. Please refer to the `GitLab CI Pipeline
   Reference <https://docs.gitlab.com/ee/ci/>`_. A helpful tool for
diff --git a/docs/developer/testing_index.rst b/docs/developer/testing_index.rst
index a063aef655f920e6e108375c65f8f1296842e81a..25f63fe19fecf37de9bba8a590fb12b402625304 100644
--- a/docs/developer/testing_index.rst
+++ b/docs/developer/testing_index.rst
@@ -19,11 +19,6 @@ It also includes tutorials for testing more specific parts such as protocol code
 
    ppx_expect
 
-.. toctree::
-   :maxdepth: 2
-
-   flextesa
-
 .. toctree::
    :maxdepth: 2
 
diff --git a/docs/user/node-configuration.rst b/docs/user/node-configuration.rst
index 418dc3ff7835b2ccee8478777a75bdf96f27c0f8..cf248b8a64461b7e95f7dd45dd23989bebea32fb 100644
--- a/docs/user/node-configuration.rst
+++ b/docs/user/node-configuration.rst
@@ -280,7 +280,7 @@ actually listening on):
    :language: json
 
 The endpoints specifically required for baking can be found in
-:src:`vendors/flextesa-lib/tezos_node.ml`.
+`tezos_node.ml of Flextesa <https://gitlab.com/tezos/flextesa/-/blob/master/src/lib/tezos_node.ml>`_.
 
 .. _configure_p2p:
 
diff --git a/manifest/main.ml b/manifest/main.ml
index 0f8f867072d6cd5b4a2f24b94bf547ef094516d1..dcddfdaf6f941aff482cae0d36eb0349431a47fb 100644
--- a/manifest/main.ml
+++ b/manifest/main.ml
@@ -311,8 +311,6 @@ let zarith_stubs_js = external_lib ~js_compatible:true "zarith_stubs_js" V.True
 
 (* VENDORED LIBS *)
 
-let flextesa = vendored_lib "flextesa"
-
 let ledgerwallet_tezos = vendored_lib "ledgerwallet-tezos"
 
 (* INTERNAL LIBS *)
@@ -3446,20 +3444,6 @@ include Tezos_raw_protocol_%s.Main
                       else S "-no-hash-check");
                       S ".";
                     ];
-                alias_rule
-                  "runtest_sandbox"
-                  ~deps:
-                    [
-                      sf
-                        ".tezos_protocol_%s.objs/native/tezos_protocol_%s.cmx"
-                        name_underscore
-                        name_underscore;
-                    ]
-                  ~action:[S "progn"];
-                alias_rule
-                  "runtest"
-                  ~package:(sf "tezos-protocol-%s" name_dash)
-                  ~alias_deps:["runtest_sandbox"];
               ]
       in
       let _functor =
@@ -4900,14 +4884,6 @@ let _tezos_codec =
          ])
     ~linkall:true
 
-let _tezos_sandbox =
-  private_exe
-    "main"
-    ~path:"src/bin_sandbox"
-    ~opam:""
-    ~bisect_ppx:false
-    ~deps:[tezos_base; tezos_base_unix; fmt; flextesa]
-
 let _tezos_proxy_server =
   public_exe
     "tezos-proxy-server"
diff --git a/sandbox.Makefile b/sandbox.Makefile
deleted file mode 100644
index 8e608e2b19756011b36aeba7f414f2eddbfe936f..0000000000000000000000000000000000000000
--- a/sandbox.Makefile
+++ /dev/null
@@ -1,61 +0,0 @@
-TMP=/tmp
-
-CURRENT_PROTO_HASH=PtJakartaiDz69SfDDLXJSiuZqTSeSKRDbKVZC8MNzJnvRjvnGw
-CURRENT_PROTO_NAME=Jakarta
-
-.PHONY: all
-all: accusations_simple_double_endorsing
-
-# These are the targets that are actually run in ./.gitlab/ci/test/integration.yml
-ci: all
-
-
-# The following rules define how to build Tezos binaries if they are
-# missing.
-#
-# We only run "dune build" if it is strictly necessary.  The CI stores
-# the binaries as artefacts, but not _build.  Those rules allow us to
-# use these artefacts.  Systematically running dune would cause a full
-# rebuild since _build is not an artefact.
-#
-# The drawback of writing the rules this way is that if we need
-# several binaries, we call dune several times, which takes a bit
-# longer than calling it only once (dune scans the whole repository
-# first).
-#
-# The real drawback of writing the rules this way is that during
-# development, if you change something in the sources, as the binaries
-# exist, nothing is recompiled!
-
-tezos-node:
-	dune build src/bin_node/main.exe
-	cp _build/default/src/bin_node/main.exe $@
-
-tezos-client:
-	dune build src/bin_client/main_client.exe
-	cp _build/default/src/bin_client/main_client.exe $@
-
-tezos-admin-client:
-	dune build src/bin_client/main_admin.exe
-	cp _build/default/src/bin_client/main_admin.exe $@
-
-tezos-sandbox:
-	dune build src/bin_sandbox/main.exe
-	cp _build/default/src/bin_sandbox/main.exe $@
-
-# The following rules define how to run sandbox (i.e. Flextesa) integration tests.
-# Note how base ports are well separated to be able to run them in parallel if needed
-# (with make -j).
-#
-# Those rules are directly translated from src/bin_sandbox/dune rules.
-
-.PHONY: accusations_simple_double_endorsing
-accusations_simple_double_endorsing: tezos-sandbox tezos-client tezos-node
-	./tezos-sandbox accusations simple-double-endorsing \
-	  --root-path ${TMP}/flextesa-acc-sde/ \
-	  --with-timestamp \
-	  --base-port 11_000 \
-	  --tezos-client-binary ./tezos-client \
-	  --tezos-node-binary ./tezos-node \
-	  --protocol-hash ${CURRENT_PROTO_HASH} \
-	  --protocol-kind ${CURRENT_PROTO_NAME}
diff --git a/scripts/remove-old-protocols.sh b/scripts/remove-old-protocols.sh
index 2d642edc7705dc163da9124ed5f7b60b0dbc3bf1..c5d24141c10ec98105037d180a7b388b25b643e8 100755
--- a/scripts/remove-old-protocols.sh
+++ b/scripts/remove-old-protocols.sh
@@ -7,7 +7,6 @@ set -euo pipefail
 # At least the following other jobs still compile with all protocols:
 # - Docker images (for master and releases)
 # - static binaries (only for releases)
-# Note: src/proto_000_Ps9mPmXa is needed by Flextesa
 
 all_protocols=$(find src -maxdepth 1 -type d -regex 'src/proto.*' | \
                 cut -d '_' -f2- | \
diff --git a/scripts/version.sh b/scripts/version.sh
index 252c38f678cb3592376c480974bf06994956de87..c2688756e4971f166ca701c181a1a1fd4069abf7 100755
--- a/scripts/version.sh
+++ b/scripts/version.sh
@@ -25,7 +25,7 @@ export full_opam_repository_tag=e637ce47cd89e52fce3a0928ddbe3439c6616479
 ## opam_repository is an additional, tezos-specific opam repository.
 ## This value MUST be the same as `build_deps_image_version` in `.gitlab/ci/templates.yml
 export opam_repository_url=https://gitlab.com/tezos/opam-repository
-export opam_repository_tag=98a3fd9095e9008f5f687266da8faf798db2240c
+export opam_repository_tag=7b619e8f294911d4ee5930b3eb5c334dcf710e65
 export opam_repository_git=$opam_repository_url.git
 export opam_repository=$opam_repository_git\#$opam_repository_tag
 
diff --git a/src/bin_sandbox/command_accusations.ml b/src/bin_sandbox/command_accusations.ml
deleted file mode 100644
index 4426258e903f673e5401ac500a80f145ea815daf..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_accusations.ml
+++ /dev/null
@@ -1,983 +0,0 @@
-open Flextesa
-open Internal_pervasives
-open Console
-
-let default_attempts = 35
-
-let little_mesh_with_bakers ?base_port ?generate_kiln_config state ~protocol
-    ~starting_level ~node_exec ~client_exec ~bakers () =
-  let* () = Helpers.clear_root state in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Ready to start"; af "Root path deleted."]
-  in
-  let block_interval = 1 in
-  let protocol, baker_list =
-    let open Tezos_protocol in
-    let bakers = List.take protocol.bootstrap_accounts bakers in
-    let timestamp_delay =
-      let year = 3600 * 24 * 365 in
-      Some (-year)
-    in
-    ( {
-        protocol with
-        time_between_blocks = [block_interval; 0];
-        minimal_block_delay = block_interval;
-        timestamp_delay;
-        bootstrap_accounts =
-          List.map protocol.bootstrap_accounts ~f:(fun (n, v) ->
-              if List.exists bakers ~f:(fun baker -> Poly.equal n (fst baker))
-              then (n, v)
-              else (n, 1_000L));
-      },
-      bakers )
-  in
-  let net_size = 3 in
-  let topology = Test_scenario.Topology.(mesh "Simple" net_size) in
-  let all_nodes =
-    Test_scenario.Topology.build
-      topology
-      ?base_port
-      ~make_node:(fun id ~expected_connections ~rpc_port ~p2p_port peers ->
-        Tezos_node.make
-          ~exec:node_exec
-          ~protocol
-          id
-          ~expected_connections
-          ~rpc_port
-          ~p2p_port
-          peers)
-  in
-  let* () = Helpers.dump_connections state all_nodes in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes:all_nodes
-      @ [secret_keys state ~protocol; Log_recorder.Operations.show_all state]) ;
-  let* () =
-    Test_scenario.Network.(start_up state ~client_exec (make all_nodes))
-  in
-  let baker nth_node =
-    let nth_baker = nth_node % List.length baker_list in
-    let key_name = sprintf "b%d" nth_baker in
-    let node = List.nth_exn all_nodes nth_node in
-    let client = Tezos_client.of_node node ~exec:client_exec in
-    let baker_account = List.nth_exn baker_list nth_baker in
-    let bak =
-      Tezos_client.Keyed.make
-        client
-        ~key_name
-        ~secret_key:(Tezos_protocol.Account.private_key (fst baker_account))
-    in
-    let* _ = Tezos_client.Keyed.initialize state bak in
-    return (client, bak)
-  in
-  let* client_0, baker_0 = baker 0 in
-  let* client_1, baker_1 = baker 1 in
-  let* client_2, baker_2 = baker 2 in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      arbitrary_commands_for_each_and_all_clients
-        state
-        ~clients:[client_0; client_1; client_2]) ;
-  let* _ =
-    Asynchronous_result.map_option generate_kiln_config ~f:(fun kiln_config ->
-        let* chain_id_json =
-          Tezos_client.rpc
-            state
-            ~client:client_0
-            `Get
-            ~path:"/chains/main/chain_id"
-        in
-        let network_id =
-          match chain_id_json with `String s -> s | _ -> assert false
-        in
-        let* () =
-          Kiln.Configuration_directory.generate
-            state
-            kiln_config
-            ~peers:
-              (List.map all_nodes ~f:(fun {Tezos_node.p2p_port; _} -> p2p_port))
-            ~sandbox_json:(Tezos_protocol.sandbox_path state protocol)
-            ~nodes:
-              (List.map all_nodes ~f:(fun {Tezos_node.rpc_port; _} ->
-                   sprintf "http://localhost:%d" rpc_port))
-            ~bakers:
-              (List.map
-                 protocol.Tezos_protocol.bootstrap_accounts
-                 ~f:(fun (account, _) ->
-                   Tezos_protocol.Account.(name account, pubkey_hash account)))
-            ~network_string:network_id
-            ~node_exec
-            ~client_exec
-        in
-        return EF.(wf "Kiln was configured at `%s`" kiln_config.path))
-  in
-  let bake msg baker = Tezos_client.Keyed.bake state baker msg in
-  let* () =
-    List.fold
-      (List.init (starting_level - 1) ~f:(fun n -> n))
-      ~init:(return ()) (* We are already at level 1, we bake 7 times: *)
-      ~f:(fun pm n ->
-        let* () = pm in
-        Helpers.wait_for
-          state
-          ~attempts:default_attempts
-          ~seconds:8.
-          (fun _attempt ->
-            Asynchronous_result.bind_on_result
-              (bake
-                 (sprintf "first bakes: [%d/%d]" (n + 1) (starting_level - 1))
-                 baker_0)
-              ~f:(function
-                | Ok () -> return (`Done ())
-                | Error _ -> return (`Not_done "not baked yet"))))
-  in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      all_nodes
-      (`Equal_to starting_level)
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          af "Clients ready";
-          af "Node 0 baked %d times." (starting_level - 1);
-          af "All nodes should be at level %d." starting_level;
-        ]
-  in
-  return (all_nodes, client_0, baker_0, client_1, baker_1, client_2, baker_2)
-
-let wait_for_operation_in_mempools state ~nodes:all_nodes ~kind ~client_exec how
-    =
-  let init, combine =
-    match how with `At_least_one -> (false, ( || )) | `All -> (true, ( && ))
-  in
-  Helpers.wait_for state ~attempts:default_attempts ~seconds:8. (fun _ ->
-      let* done_ =
-        List.fold ~init:(return init) all_nodes ~f:(fun prev_m node ->
-            let* prev = prev_m in
-            let client = Tezos_client.of_node node ~exec:client_exec in
-            let* client_result =
-              Tezos_client.mempool_has_operation state ~client ~kind
-            in
-            return (combine client_result prev))
-      in
-      if done_ then return (`Done ())
-      else
-        return
-          (`Not_done (sprintf "Waiting for %S to show up in the mempool" kind)))
-
-let simple_double_baking ~starting_level ?generate_kiln_config ~state ~protocol
-    ~base_port node_exec client_exec () =
-  let* all_nodes, client_0, baker_0, client_1, baker_1, client_2, baker_2 =
-    little_mesh_with_bakers
-      ~bakers:1
-      ~protocol
-      state
-      ~node_exec
-      ~client_exec
-      ()
-      ~base_port
-      ~starting_level
-      ?generate_kiln_config
-  in
-  let kill_nth nth = List.nth_exn all_nodes nth |> Helpers.kill_node state in
-  let restart_nth nth =
-    List.nth_exn all_nodes nth |> Helpers.restart_node ~client_exec state
-  in
-  let number_of_lonely_bakes = 1 in
-  let* () = kill_nth 1 in
-  let* () = kill_nth 2 in
-  (* Bake one block less i.e., (number_of_lonely_bakes - 1) inject an operation
-     (here a transfer) to generate a different block hash for the next baking
-     command *)
-  let* () =
-    Loop.n_times (number_of_lonely_bakes - 1) (fun _ ->
-        Tezos_client.Keyed.bake state baker_0 "Bake-on-0")
-  in
-  let transfer client =
-    match protocol.Tezos_protocol.bootstrap_accounts with
-    | (src, _) :: (dst, _) :: _ ->
-        let src_key = Tezos_protocol.Account.pubkey_hash src
-        and dst_key = Tezos_protocol.Account.pubkey_hash dst in
-        let* _ =
-          Tezos_client.successful_client_cmd
-            state
-            ~client
-            [
-              "--wait";
-              "none";
-              "transfer";
-              "1";
-              "from";
-              src_key;
-              "to";
-              dst_key;
-              "--fee";
-              "0.05";
-            ]
-        in
-        Asynchronous_result.return ()
-    | _ ->
-        (* This case should not happen with bootstrap_accounts *)
-        Asynchronous_result.return ()
-  in
-  let* () = transfer client_0 in
-  let* () = Tezos_client.Keyed.bake state baker_0 "Bake-on-0" in
-  let* baking_0_header =
-    Tezos_client.get_block_header state ~client:client_0 `Head
-  in
-  (* This baking will have better fitness so other nodes will have to fetch it. *)
-  let* () =
-    Tezos_client.Keyed.endorse state baker_0 "endorsing lonely bake-on-0"
-  in
-  let* () = System.sleep 1. in
-  let* () = kill_nth 0 in
-  let* () = restart_nth 1 in
-  let* () = restart_nth 2 in
-  let* () =
-    Loop.n_times number_of_lonely_bakes (fun _ ->
-        Tezos_client.Keyed.bake state baker_1 "Bake-on-1")
-  in
-  let* baking_1_header =
-    Tezos_client.get_block_header state ~client:client_1 `Head
-  in
-  let* () = restart_nth 0 in
-  let* () = Tezos_client.Keyed.bake state baker_0 "Bake-on-0" in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      all_nodes
-      (`At_least (starting_level + number_of_lonely_bakes + 1))
-  in
-  let* head_hash_json =
-    Tezos_client.rpc
-      state
-      ~client:client_1
-      `Get
-      ~path:"/chains/main/blocks/head/hash"
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          af "About to forge";
-          ef_json "Baking 0" baking_0_header;
-          ef_json "Baking 1" baking_1_header;
-          ef_json "Head hash" head_hash_json;
-        ]
-  in
-  let clean header =
-    let open Jqo in
-    remove_field header ~name:"hash"
-    |> remove_field ~name:"chain_id"
-    |> remove_field ~name:"protocol"
-  in
-  let json =
-    `O
-      [
-        ("branch", head_hash_json);
-        ( "contents",
-          `A
-            [
-              `O
-                [
-                  ("kind", `String "double_baking_evidence");
-                  ("bh1", clean baking_0_header);
-                  ("bh2", clean baking_1_header);
-                ];
-            ] );
-      ]
-  in
-  let* result = Tezos_client.Keyed.forge_and_inject state baker_1 ~json in
-  let next_level = starting_level + number_of_lonely_bakes + 1 in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          af "Waiting for accuser to notice double baking";
-          ef_json "Result of injection" result;
-          af "All nodes reaching level %d" next_level;
-        ]
-  in
-  let* () =
-    wait_for_operation_in_mempools
-      state
-      ~nodes:all_nodes
-      ~kind:"double_baking_evidence"
-      ~client_exec
-      `All
-  in
-  let* () =
-    Tezos_client.Keyed.bake state baker_2 (sprintf "all at lvl %d" next_level)
-  in
-  let next_level = next_level + 1 in
-  let* () =
-    Tezos_client.Keyed.bake state baker_2 (sprintf "all at lvl %d" next_level)
-  in
-  let last_level = next_level + 1 in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Just baked level %d" last_level]
-  in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      all_nodes
-      (`At_least last_level)
-  in
-  let* () =
-    Helpers.wait_for state ~attempts:5 ~seconds:3. (fun _ ->
-        let* done_ =
-          Tezos_client.block_has_operation
-            state
-            ~client:client_2
-            ~level:last_level
-            ~kind:"double_baking_evidence"
-        in
-        if done_ then return (`Done ())
-        else
-          return
-            (`Not_done
-              (sprintf
-                 "Waiting for accusation to show up in block %d"
-                 last_level)))
-  in
-  say state EF.(af "Test done.")
-
-let find_endorsement_in_mempool state ~client =
-  let open Poly in
-  Helpers.wait_for state ~attempts:4 ~seconds:2. (fun _ ->
-      let* endorsement_opt =
-        Tezos_client.find_applied_in_mempool state ~client ~f:(fun o ->
-            Jqo.field o ~k:"contents"
-            |> Jqo.list_exists ~f:(fun op ->
-                   (* Dbg.e EF.(ef_json "op" op) ; *)
-                   Jqo.field op ~k:"kind" = `String "endorsement_with_slot"))
-      in
-      match endorsement_opt with
-      | None -> return (`Not_done (sprintf "No endorsement so far"))
-      | Some e -> return (`Done e))
-
-let simple_double_endorsement ~starting_level ?generate_kiln_config ~state
-    ~protocol ~base_port node_exec client_exec () =
-  (* skip for alpha/Tenderbake *)
-  match protocol.Tezos_protocol.kind with
-  | `Ithaca | `Jakarta | `Alpha ->
-      (* The same reason as for tests_python/tests_alpha/test_double_endorsement.py applies here *)
-      let* () =
-        say
-          state
-          (EF.atom
-             "Skipping simple_double_endorsement test: irrelevant to \
-              Tenderbake (alpha)")
-      in
-      Asynchronous_result.return ()
-  | _ ->
-      let* all_nodes, client_0, baker_0, client_1, baker_1, client_2, baker_2 =
-        little_mesh_with_bakers
-          ~bakers:2
-          ~protocol
-          state
-          ~node_exec
-          ~client_exec
-          ()
-          ~starting_level
-          ~base_port
-          ?generate_kiln_config
-      in
-      (* 2 bakers ⇒ baker_0 and baker_2 are for the same key on ≠ nodes *)
-      assert (
-        Tezos_client.Keyed.(
-          String.equal baker_0.key_name baker_2.key_name
-          && String.equal baker_0.secret_key baker_2.secret_key)) ;
-      let node_0 = List.nth_exn all_nodes 0 in
-      let node_1 = List.nth_exn all_nodes 1 in
-      let node_2 = List.nth_exn all_nodes 2 in
-      let baker_1_n0 =
-        let open Tezos_client.Keyed in
-        let {key_name; secret_key; _} = baker_1 in
-        make client_0 ~key_name ~secret_key
-      in
-      let* _ = Tezos_client.Keyed.initialize state baker_1_n0 in
-      let* () = Helpers.kill_node state node_1 in
-      let* () = Helpers.kill_node state node_2 in
-      (* Inject an operation to generate a different block's hash *)
-      let* () =
-        Tezos_client.Keyed.endorse state baker_0 "endorsing lonely bake-on-0"
-      in
-      let* () =
-        Tezos_client.Keyed.bake state baker_0 "baker-0 baking with node 0"
-      in
-      let* () =
-        Tezos_client.Keyed.endorse state baker_0 "baker-0 endorsing with node 0"
-      in
-      let* endorsement_0 = find_endorsement_in_mempool state ~client:client_0 in
-      let* () =
-        Tezos_client.Keyed.endorse
-          state
-          baker_1_n0
-          "baker-1 endorsing with node 0"
-      in
-      let* () = Helpers.kill_node state node_0 in
-      let* () = Helpers.restart_node state node_2 ~client_exec in
-      let* () =
-        Tezos_client.Keyed.bake state baker_2 "baker-0 baking with node 2"
-      in
-      let* () =
-        Tezos_client.Keyed.endorse state baker_2 "baker-0 endorsing with node 2"
-      in
-      let* endorsement_1 = find_endorsement_in_mempool state ~client:client_2 in
-      let* () =
-        say
-          state
-          EF.(
-            list
-              [
-                ef_json "Endorsement 0:" endorsement_0;
-                ef_json "Endorsement 1:" endorsement_1;
-              ])
-      in
-      let* () = Helpers.restart_node state node_1 ~client_exec in
-      let* () =
-        Test_scenario.Queries.wait_for_all_levels_to_be
-          state
-          ~attempts:default_attempts
-          ~seconds:8.
-          [node_1; node_2]
-          (`Equal_to (starting_level + 1))
-      in
-      let* () = Helpers.restart_node state node_0 ~client_exec in
-      (* TODO: understand why this kick in the butt is necessary for node
-         2 (seems like the node was not getting to level starting+2 without
-         this). *)
-      let* () = Helpers.kill_node state node_2 in
-      let* () = Helpers.restart_node state node_2 ~client_exec in
-      let* () =
-        Test_scenario.Queries.wait_for_all_levels_to_be
-          state
-          ~attempts:default_attempts
-          ~seconds:8.
-          all_nodes
-          (`Equal_to (starting_level + 1))
-      in
-      let* head_hash_json =
-        Tezos_client.rpc
-          state
-          ~client:client_1
-          `Get
-          ~path:"/chains/main/blocks/head/hash"
-      in
-      let double_endorsement =
-        let transform_endorsement endorsement =
-          match Jqo.field ~k:"contents" endorsement with
-          | `A [one] -> (Jqo.field ~k:"endorsement" one, Jqo.field ~k:"slot" one)
-          | _ -> assert false
-        in
-        let inlined_endorsement_1, slot = transform_endorsement endorsement_0 in
-        let inlined_endorsement_2, _ = transform_endorsement endorsement_1 in
-        `O
-          [
-            ("branch", head_hash_json);
-            ( "contents",
-              `A
-                [
-                  `O
-                    [
-                      ("kind", `String "double_endorsement_evidence");
-                      ("op1", inlined_endorsement_1);
-                      ("op2", inlined_endorsement_2);
-                      ("slot", slot);
-                    ];
-                ] );
-          ]
-      in
-      let* () =
-        Interactive_test.Pauser.generic
-          state
-          EF.[ef_json "About to forge" double_endorsement]
-      in
-      let* result =
-        Tezos_client.Keyed.forge_and_inject
-          state
-          baker_1
-          ~json:double_endorsement
-      in
-      let* () =
-        Interactive_test.Pauser.generic
-          state
-          EF.[ef_json "Result of injection" result]
-      in
-      let* () =
-        wait_for_operation_in_mempools
-          state
-          ~nodes:[node_1]
-          ~kind:"double_endorsement_evidence"
-          ~client_exec
-          `All
-      in
-      let last_level = starting_level + 2 in
-      let* () =
-        Tezos_client.Keyed.bake state baker_1 (sprintf "level %d" last_level)
-      in
-      let* () =
-        Tezos_client.Keyed.endorse
-          state
-          baker_1
-          (sprintf "endorse level %d" last_level)
-      in
-      let* () =
-        Test_scenario.Queries.wait_for_all_levels_to_be
-          state
-          ~attempts:default_attempts
-          ~seconds:8.
-          all_nodes
-          (`Equal_to last_level)
-      in
-      let* () =
-        Helpers.wait_for state ~attempts:10 ~seconds:4. (fun _ ->
-            (* We check that client-2 sees the evidence from baker-1 *)
-            let* done_ =
-              Tezos_client.block_has_operation
-                state
-                ~client:client_2
-                ~level:last_level
-                ~kind:"double_endorsement_evidence"
-            in
-            if done_ then return (`Done ())
-            else
-              return
-                (`Not_done
-                  (sprintf
-                     "Waiting for accusation to show up in block %d"
-                     last_level)))
-      in
-      say state EF.(af "Test done.")
-
-let with_accusers ~state ~protocol ~base_port node_exec accuser_exec client_exec
-    () =
-  let* () = Helpers.clear_root state in
-  let block_interval = 2 in
-  let protocol, baker_0_account =
-    let d = protocol in
-    let open Tezos_protocol in
-    let baker = List.hd_exn d.bootstrap_accounts in
-    ( {
-        d with
-        time_between_blocks = [block_interval; block_interval * 2];
-        minimal_block_delay = block_interval;
-        bootstrap_accounts =
-          List.map d.bootstrap_accounts ~f:(fun (n, v) ->
-              if Poly.(n = fst baker) then (n, v) else (n, 1_000L));
-      },
-      baker )
-  in
-  let topology =
-    Test_scenario.Topology.(
-      net_in_the_middle "AT-" (mesh "Mid" 3) (mesh "Main" 4) (mesh "Acc" 4))
-  in
-  let mesh_nodes, intermediary_nodes, accuser_nodes =
-    Test_scenario.Topology.build
-      topology
-      ~base_port
-      ~make_node:(fun id ~expected_connections ~rpc_port ~p2p_port peers ->
-        Tezos_node.make
-          ~exec:node_exec
-          ~protocol
-          id
-          ~expected_connections
-          ~rpc_port
-          ~p2p_port
-          peers)
-  in
-  let all_nodes = mesh_nodes @ intermediary_nodes @ accuser_nodes in
-  let* () = Helpers.dump_connections state all_nodes in
-  let* () =
-    Test_scenario.Network.(start_up state ~client_exec (make all_nodes))
-  in
-  let start_accuser nod =
-    let client = Tezos_client.of_node nod ~exec:client_exec in
-    let acc = Tezos_daemon.accuser_of_node ~exec:accuser_exec ~client nod in
-    let* _ = Running_processes.start state (Tezos_daemon.process state acc) in
-    return ()
-  in
-  let* () = List_sequential.iter accuser_nodes ~f:start_accuser in
-  let key_name = "b0" in
-  let baker nth =
-    let node = List.nth_exn all_nodes nth in
-    let client = Tezos_client.of_node node ~exec:client_exec in
-    let bak =
-      Tezos_client.Keyed.make
-        client
-        ~key_name
-        ~secret_key:(Tezos_protocol.Account.private_key (fst baker_0_account))
-    in
-    let* _ = Tezos_client.Keyed.initialize state bak in
-    return (client, bak)
-  in
-  let* client_0, baker_0 = baker 0 in
-  let* client_1, baker_1 = baker 1 in
-  let* client_2, baker_2 = baker 2 in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes:all_nodes
-      @ [secret_keys state ~protocol; Log_recorder.Operations.show_all state]
-      @ arbitrary_commands_for_each_and_all_clients
-          state
-          ~clients:[client_0; client_1; client_2]) ;
-  let pause ?force msgs = Interactive_test.Pauser.generic state ?force msgs in
-  let starting_level = 10 in
-  let* () =
-    List.fold
-      (List.init (starting_level - 1) ~f:(fun n -> n))
-      ~init:(return ()) (* We are already at level 1, we bake 7 times: *)
-      ~f:(fun pm n ->
-        let* () = pm in
-        Tezos_client.Keyed.bake
-          state
-          baker_0
-          (sprintf "first bakes: [%d/%d]" (n + 1) (starting_level - 1)))
-  in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      all_nodes
-      (`Equal_to starting_level)
-  in
-  let* () =
-    pause
-      EF.
-        [
-          af "Two clients ready";
-          af "Node 0 baked %d times." (starting_level - 1);
-          af "All nodes should be at level %d." starting_level;
-        ]
-  in
-  let transfer _msg client =
-    let dest =
-      List.random_element_exn protocol.Tezos_protocol.bootstrap_accounts
-      |> fst |> Tezos_protocol.Account.pubkey_hash
-    in
-    let* res =
-      Tezos_client.successful_client_cmd
-        state
-        ~client
-        [
-          "--wait";
-          "none";
-          "transfer";
-          "1";
-          "from";
-          key_name;
-          "to";
-          dest;
-          "--fee";
-          "0.05";
-        ]
-    in
-    say
-      state
-      EF.(
-        desc
-          (af "Successful transfer (%s):" client.Tezos_client.id)
-          (ocaml_string_list res#out))
-  in
-  let* () =
-    List_sequential.iter intermediary_nodes ~f:(fun x ->
-        Helpers.kill_node state x)
-  in
-  let kill_all_but nodes iths =
-    List_sequential.iteri nodes ~f:(fun ith n ->
-        if List.mem iths ith ~equal:Int.equal then return ()
-        else Helpers.kill_node state n)
-  in
-  let kill_nth_node nodes nth =
-    Helpers.kill_node
-      state
-      (Option.value_exn ~message:"kill_nth_node" (List.nth nodes nth))
-  in
-  let restart_nth_node nodes nth =
-    Helpers.restart_node
-      state
-      ~client_exec
-      (Option.value_exn ~message:"restart_nth_node" (List.nth nodes nth))
-  in
-  let get_block_header ~client block =
-    let path =
-      sprintf
-        "/chains/main/blocks/%s/header"
-        (match block with `Head -> "head" | `Level i -> Int.to_string i)
-    in
-    Tezos_client.rpc state ~client `Get ~path
-  in
-  let* () = kill_all_but mesh_nodes [0] in
-  let number_of_lonely_bakes = 1 in
-  let* () = pause EF.[af "Node 0 is the only one alive"] in
-  let* () = transfer "node0 only alive" client_0 in
-  let* () =
-    Loop.n_times number_of_lonely_bakes (fun n ->
-        Tezos_client.Keyed.bake state baker_0 (sprintf "n0 only alive: %d" n))
-  in
-  let* _baking_0_header = get_block_header ~client:client_0 `Head in
-  let* () = Tezos_client.Keyed.endorse state baker_0 "self-endorsing" in
-  let* () = Tezos_client.Keyed.bake state baker_0 "baking self-endorsement" in
-  let* () = kill_nth_node mesh_nodes 0 in
-  let* () = restart_nth_node mesh_nodes 1 in
-  let* () = transfer "node1 only one alive" client_1 in
-  let* () =
-    Loop.n_times number_of_lonely_bakes (fun _ ->
-        Tezos_client.Keyed.bake state baker_1 "after transfer")
-  in
-  let* _baking_1_header = get_block_header ~client:client_1 `Head in
-  let* () = kill_nth_node mesh_nodes 1 in
-  let* () =
-    pause
-      EF.
-        [
-          af "Node 0 was killed";
-          af "Node 1 was restarted";
-          af "Node 1 transferred";
-          af "Node 1 baked";
-          af "Node 1 was killed";
-        ]
-  in
-  let* () =
-    List.fold ~init:(return ()) intermediary_nodes ~f:(fun prev x ->
-        let* () = prev in
-        Helpers.restart_node state ~client_exec x)
-  in
-  let node_0 = List.nth_exn mesh_nodes 0 in
-  let except_0 l =
-    List.filter l ~f:Tezos_node.(fun n -> Poly.(n.id <> node_0.id))
-  in
-  let* () =
-    List_sequential.iter
-      (except_0 mesh_nodes)
-      ~f:(Helpers.restart_node state ~client_exec)
-  in
-  let* () = pause EF.[af "All nodes restarted Except 0"] in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      (except_0 all_nodes)
-      (`At_least (starting_level + number_of_lonely_bakes))
-  in
-  let* () = Helpers.restart_node state ~client_exec node_0 in
-  let* () = pause EF.[af "Restarted 0"] in
-  let* () =
-    Helpers.wait_for state ~attempts:default_attempts ~seconds:8. (fun _ ->
-        let* done_ =
-          List.fold ~init:(return false) accuser_nodes ~f:(fun prev_m node ->
-              let* prev = prev_m in
-              let client = Tezos_client.of_node node ~exec:client_exec in
-              let* client_result =
-                Tezos_client.mempool_has_operation
-                  state
-                  ~client
-                  ~kind:"double_baking_evidence"
-              in
-              return (client_result || prev))
-        in
-        if done_ then return (`Done ())
-        else
-          return
-            (`Not_done
-              (sprintf "Waiting for accusation to show up in the mempool")))
-  in
-  let* () =
-    Tezos_client.Keyed.bake
-      state
-      baker_2
-      (sprintf "all at lvl %d" (starting_level + number_of_lonely_bakes + 1))
-  in
-  let* () =
-    Helpers.wait_for state ~attempts:10 ~seconds:4. (fun _ ->
-        let level = starting_level + number_of_lonely_bakes + 2 in
-        let* done_ =
-          Tezos_client.block_has_operation
-            state
-            ~client:client_2
-            ~level
-            ~kind:"double_baking_evidence"
-        in
-        if done_ then return (`Done ())
-        else
-          return
-            (`Not_done
-              (sprintf "Waiting for accusation to show up in block %d" level)))
-  in
-  let* () =
-    pause
-      EF.
-        [
-          af "One more baking (level should include accusation)";
-          af
-            "All nodes reaching level %d"
-            (starting_level + number_of_lonely_bakes + 2);
-        ]
-  in
-  let* () = Tezos_client.Keyed.bake state baker_1 "a couple more" in
-  Test_scenario.Queries.wait_for_all_levels_to_be
-    state
-    ~attempts:default_attempts
-    ~seconds:8.
-    all_nodes
-    (`At_least (starting_level + number_of_lonely_bakes + 1))
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"mininet"
-      ()
-  in
-  let docs = Manpage_builder.section_test_scenario base_state in
-  let pf fmt = ksprintf (fun s -> `P s) fmt in
-  let tests =
-    let test variant name title man = (variant, name, title, man) in
-    [
-      test
-        `With_accusers
-        "with-accusers"
-        "Network With Accusers"
-        (pf
-           "This test builds a network with 3 interconnected meshes: Main, \
-            Intermediate, and Accuser.");
-      test
-        `Simple_double_baking
-        "simple-double-baking"
-        "Simple Network With Manual Double Baking Accusation"
-        (pf
-           "This test builds a very simple 3-piece network, makes a baker \
-            double bake and $(i,manually) inserts a double-baking accusation.");
-      test
-        `Simple_double_endorsing
-        "simple-double-endorsing"
-        "Simple Network With Manual Double Endorsing Accusation"
-        (pf
-           "This test builds a very simple 3-piece network, makes a baker \
-            double endorse and $(i,manually) inserts a double-endorsement \
-            accusation.");
-    ]
-  in
-  let term =
-    const
-      (fun
-        test
-        base_port
-        (`Starting_level starting_level)
-        bnod
-        bcli
-        accex
-        generate_kiln_config
-        protocol
-        state
-      ->
-        let checks () =
-          let acc = if Poly.(test = `With_accusers) then [accex] else [] in
-          Helpers.System_dependencies.precheck
-            state
-            `Or_fail
-            ~executables:(acc @ [bnod; bcli])
-        in
-        let actual_test () =
-          match test with
-          | `With_accusers ->
-              let* () = checks () in
-              with_accusers ~state bnod accex bcli ~base_port () ~protocol
-          | `Simple_double_baking ->
-              let* () = checks () in
-              simple_double_baking
-                ~state
-                bnod
-                bcli
-                ~base_port
-                ?generate_kiln_config
-                ~starting_level
-                ~protocol
-                ()
-          | `Simple_double_endorsing ->
-              let* () = checks () in
-              simple_double_endorsement
-                ~state
-                bnod
-                bcli
-                ~base_port
-                ?generate_kiln_config
-                ~starting_level
-                ~protocol
-                ()
-        in
-        Test_command_line.Run_command.or_hard_fail
-          state
-          ~pp_error
-          (Interactive_test.Pauser.run_test ~pp_error state actual_test))
-    $ Arg.(
-        required
-          (pos
-             0
-             (some (enum (List.map tests ~f:(fun (v, n, _, _) -> (n, v)))))
-             None
-             (info [] ~docs ~docv:"TEST-NAME" ~doc:"Choose which test to run.")))
-    $ Arg.(
-        value & opt int 30_000
-        & info ["base-port"] ~docs ~doc:"Base port number to build upon.")
-    $ Arg.(
-        const (fun l -> `Starting_level l)
-        $ value
-            (opt
-               int
-               5
-               (info
-                  ~docs
-                  ["starting-level"]
-                  ~doc:
-                    "Initial block-level to reach before actually starting the \
-                     test.")))
-    $ Tezos_executable.cli_term base_state `Node "tezos"
-    $ Tezos_executable.cli_term base_state `Client "tezos"
-    $ Tezos_executable.cli_term base_state `Accuser "tezos"
-    $ Kiln.Configuration_directory.cli_term base_state
-    $ Tezos_protocol.cli_term base_state
-    $ Test_command_line.cli_state ~name:"accusing" ()
-  in
-  let info =
-    let doc = "Sandbox networks which record double-bakings." in
-    let man : Manpage.block list =
-      [
-        `S "ACCUSATION TESTS";
-        pf
-          "This command provides %d tests which use network sandboxes to make \
-           double-bakings and double-endorsements happen."
-          (List.length tests);
-        `Blocks
-          (List.map tests ~f:(fun (_, n, tit, m) ->
-               `Blocks [pf "* $(b,`%s`): $(i,%s)." n tit; `Noblank; m]));
-      ]
-    in
-    Cmd.info ~man ~doc "accusations"
-  in
-  Cmd.v info term
diff --git a/src/bin_sandbox/command_daemons_protocol_change.ml b/src/bin_sandbox/command_daemons_protocol_change.ml
deleted file mode 100644
index 601ece57d945295aeca6e5d9c71cc61cf2dffb9a..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_daemons_protocol_change.ml
+++ /dev/null
@@ -1,788 +0,0 @@
-open Flextesa
-open Internal_pervasives
-open Console
-
-let failf fmt = ksprintf (fun s -> fail (`Scenario_error s)) fmt
-
-let wait_for_voting_period ?level_within_period state ~protocol ~client
-    ~attempts period =
-  let is_expected_period (voting_period : (string * Ezjsonm.value) list)
-      period_name =
-    match Stdlib.List.assoc_opt "voting_period" voting_period with
-    | Some (`O obj) -> (
-        match Stdlib.List.assoc_opt "kind" obj with
-        | Some (`String p) -> String.equal p period_name
-        | _ -> false)
-    | _ -> false
-  in
-  let period_name = Tezos_protocol.voting_period_to_string protocol period in
-  let message =
-    sprintf
-      "Waiting for voting period: `%s`%s"
-      period_name
-      (Option.value_map
-         level_within_period
-         ~default:""
-         ~f:(sprintf " (and level-within-period ≥ %d)"))
-  in
-  let* () = Console.say state EF.(wf "%s" message) in
-  Helpers.wait_for state ~attempts ~seconds:10. (fun nth ->
-      let* lvl_ok =
-        Asynchronous_result.map_option level_within_period ~f:(fun lvl ->
-            let* json =
-              Tezos_client.rpc
-                state
-                ~client
-                `Get
-                ~path:"/chains/main/blocks/head/metadata"
-            in
-            try
-              let voting_period_position =
-                Jqo.field ~k:"voting_period_info" json
-                |> Jqo.field ~k:"position" |> Jqo.get_int
-              in
-              return (voting_period_position >= lvl)
-            with e ->
-              failf
-                "Cannot get level.voting_period_position: %s"
-                (Exn.to_string e))
-      in
-      let* json =
-        Tezos_client.rpc
-          state
-          ~client
-          `Get
-          ~path:"/chains/main/blocks/head/votes/current_period"
-      in
-      match json with
-      | `O voting_period
-        when is_expected_period voting_period period_name
-             && Poly.(lvl_ok = None || lvl_ok = Some true) ->
-          return (`Done (nth - 1))
-      | _ ->
-          let* res =
-            Tezos_client.successful_client_cmd
-              state
-              ~client
-              ["show"; "voting"; "period"]
-          in
-          let* () =
-            Console.say
-              state
-              EF.(
-                desc_list
-                  (wf "Voting period:")
-                  [markdown_verbatim (String.concat ~sep:"\n" res#out)])
-          in
-          return (`Not_done message))
-
-let run state ~protocol ~size ~base_port ~no_daemons_for ?external_peer_ports
-    ?generate_kiln_config ~node_exec ~client_exec ~first_baker_exec
-    ~first_endorser_exec ~first_accuser_exec ~second_baker_exec
-    ~second_endorser_exec ~second_accuser_exec ~admin_exec ~new_protocol_path
-    ~extra_dummy_proposals_batch_size ~extra_dummy_proposals_batch_levels
-    ~waiting_attempts test_variant () =
-  let* () = Helpers.clear_root state in
-  let* () =
-    Helpers.System_dependencies.precheck
-      state
-      `Or_fail
-      ~protocol_paths:[new_protocol_path]
-      ~executables:
-        [
-          node_exec;
-          client_exec;
-          first_baker_exec;
-          first_endorser_exec;
-          first_accuser_exec;
-          second_baker_exec;
-          second_endorser_exec;
-          second_accuser_exec;
-        ]
-  in
-  let* nodes, protocol =
-    Test_scenario.network_with_protocol
-      ?external_peer_ports
-      ~protocol
-      ~size
-      ~base_port
-      state
-      ~node_exec
-      ~client_exec
-  in
-  let* chain_id_json =
-    Tezos_client.rpc
-      state
-      ~client:(Tezos_client.of_node (List.hd_exn nodes) ~exec:client_exec)
-      `Get
-      ~path:"/chains/main/chain_id"
-  in
-  let network_id =
-    match chain_id_json with `String s -> s | _ -> assert false
-  in
-  let accusers =
-    List.concat_map nodes ~f:(fun node ->
-        let client = Tezos_client.of_node node ~exec:client_exec in
-        [
-          Tezos_daemon.accuser_of_node
-            ~exec:first_accuser_exec
-            ~client
-            node
-            ~name_tag:"first";
-          Tezos_daemon.accuser_of_node
-            ~exec:second_accuser_exec
-            ~client
-            node
-            ~name_tag:"second";
-        ])
-  in
-  let* () =
-    List_sequential.iter accusers ~f:(fun acc ->
-        let* _ =
-          Running_processes.start state (Tezos_daemon.process state acc)
-        in
-        return ())
-  in
-  let first_lb_vote =
-    match protocol.kind with `Alpha -> Some "pass" | _ -> None
-  in
-  let* second_lb_vote =
-    match new_protocol_path with
-    | "src/proto_alpha/lib_protocol" -> return (Some "pass")
-    | "src/proto_012_Psithaca/lib_protocol" ->
-        (* This branch can be removed after the activation of Ithaca on mainnet,
-           once we stop testing migration to Ithaca. *)
-        return None
-    | s -> failf "Unexpected proto path %s" s
-  in
-  let keys_and_daemons =
-    let pick_a_node_and_client idx =
-      match List.nth nodes ((1 + idx) % List.length nodes) with
-      | Some node -> (node, Tezos_client.of_node node ~exec:client_exec)
-      | None -> assert false
-    in
-    Tezos_protocol.bootstrap_accounts protocol
-    |> List.filter_mapi ~f:(fun idx acc ->
-           let node, client = pick_a_node_and_client idx in
-           let key = Tezos_protocol.Account.name acc in
-           if List.mem ~equal:String.equal no_daemons_for key then None
-           else
-             Some
-               ( acc,
-                 client,
-                 [
-                   Tezos_daemon.baker_of_node
-                     ~exec:first_baker_exec
-                     ~client
-                     node
-                     ~key
-                     ~name_tag:"first"
-                     ~lb_vote:first_lb_vote;
-                   Tezos_daemon.baker_of_node
-                     ~exec:second_baker_exec
-                     ~client
-                     ~name_tag:"second"
-                     node
-                     ~key
-                     ~lb_vote:second_lb_vote;
-                   Tezos_daemon.endorser_of_node
-                     ~exec:first_endorser_exec
-                     ~name_tag:"first"
-                     ~client
-                     node
-                     ~key;
-                   Tezos_daemon.endorser_of_node
-                     ~exec:second_endorser_exec
-                     ~name_tag:"second"
-                     ~client
-                     node
-                     ~key;
-                 ] ))
-  in
-  let* () =
-    List_sequential.iter keys_and_daemons ~f:(fun (acc, client, daemons) ->
-        let* () = Tezos_client.wait_for_node_bootstrap state client in
-        let key, priv = Tezos_protocol.Account.(name acc, private_key acc) in
-        let* () =
-          Tezos_client.import_secret_key state client ~name:key ~key:priv
-        in
-        let* () =
-          say
-            state
-            EF.(
-              desc_list
-                (haf "Registration-as-delegate:")
-                [
-                  desc (af "Client:") (af "%S" client.Tezos_client.id);
-                  desc (af "Key:") (af "%S" key);
-                ])
-        in
-        let* () =
-          Tezos_client.register_as_delegate state client ~key_name:key
-        in
-        let* () =
-          say
-            state
-            EF.(
-              desc_list
-                (haf "Starting daemons:")
-                [
-                  desc (af "Client:") (af "%S" client.Tezos_client.id);
-                  desc (af "Key:") (af "%S" key);
-                ])
-        in
-        List_sequential.iter daemons ~f:(fun daemon ->
-            let* _ =
-              Running_processes.start state (Tezos_daemon.process state daemon)
-            in
-            return ()))
-  in
-  let client_0 =
-    Tezos_client.of_node (List.nth_exn nodes 0) ~exec:client_exec
-  in
-  let make_admin = Tezos_admin_client.of_client ~exec:admin_exec in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes
-      @ [secret_keys state ~protocol]
-      @ arbitrary_commands_for_each_and_all_clients
-          state
-          ~make_admin
-          ~clients:(List.map nodes ~f:(Tezos_client.of_node ~exec:client_exec))) ;
-  (*
-     For each node we try to see if the node knows about the protocol,
-     if it does we're good, if not we inject it.
-     This is because `inject` fails when the node already knows a protocol.
-  *)
-  let* prot_opt =
-    List.fold ~init:(return None) nodes ~f:(fun prevm nod ->
-        let* _ = prevm in
-        let* protocol =
-          System.read_file state (new_protocol_path // "TEZOS_PROTOCOL")
-        in
-        let* hash =
-          try return Jqo.(of_string protocol |> field ~k:"hash" |> get_string)
-          with e ->
-            failf
-              "Cannot parse %s/TEZOS_PROTOCOL: %s"
-              new_protocol_path
-              (Exn.to_string e)
-        in
-        let client = Tezos_client.of_node ~exec:client_exec nod in
-        let* protocols =
-          Tezos_client.rpc state ~client `Get ~path:"/protocols"
-        in
-        match protocols with
-        | `A l
-          when List.exists l ~f:(function
-                   | `String h -> String.equal h hash
-                   | _ -> false) ->
-            let* () =
-              Console.say
-                state
-                EF.(
-                  wf
-                    "Node `%s` already knows protocol `%s`."
-                    nod.Tezos_node.id
-                    hash)
-            in
-            return (Some hash)
-        | _ ->
-            let admin = make_admin client in
-            let* _, new_protocol_hash =
-              Tezos_admin_client.inject_protocol
-                admin
-                state
-                ~path:new_protocol_path
-            in
-            let* () =
-              if String.equal new_protocol_hash hash then
-                Console.say
-                  state
-                  EF.(
-                    wf
-                      "Injected protocol `%s` in `%s`"
-                      new_protocol_hash
-                      nod.Tezos_node.id)
-              else
-                failf
-                  "Injecting protocol %s failed (≠ %s)"
-                  new_protocol_hash
-                  hash
-            in
-            return (Some hash))
-  in
-  let* new_protocol_hash =
-    match prot_opt with
-    | Some s -> return s
-    | None -> failf "protocol injection problem?"
-  in
-  let* kiln_info_opt =
-    Asynchronous_result.map_option generate_kiln_config ~f:(fun kiln_config ->
-        let* () =
-          Kiln.Configuration_directory.generate
-            state
-            kiln_config
-            ~peers:
-              (List.map nodes ~f:(fun {Tezos_node.p2p_port; _} -> p2p_port))
-            ~sandbox_json:(Tezos_protocol.sandbox_path state protocol)
-            ~nodes:
-              (List.map nodes ~f:(fun {Tezos_node.rpc_port; _} ->
-                   sprintf "http://localhost:%d" rpc_port))
-            ~bakers:
-              (List.map
-                 protocol.Tezos_protocol.bootstrap_accounts
-                 ~f:(fun (account, _) ->
-                   Tezos_protocol.Account.(name account, pubkey_hash account)))
-            ~network_string:network_id
-            ~node_exec
-            ~client_exec
-            ~protocol_execs:
-              [
-                ( protocol.Tezos_protocol.hash,
-                  first_baker_exec,
-                  first_endorser_exec );
-                (new_protocol_hash, second_baker_exec, second_endorser_exec);
-              ]
-        in
-        let msg =
-          EF.(
-            desc
-              (shout "Kiln-Configuration DONE")
-              (wf "Kiln was configured at `%s`" kiln_config.path))
-        in
-        let* () = Console.say state msg in
-        return msg)
-  in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:waiting_attempts
-      ~seconds:10.
-      nodes
-      (* TODO: wait for /chains/main/blocks/head/votes/listings to be
-         non-empty instead of counting blocks *)
-      (`At_least protocol.Tezos_protocol.blocks_per_voting_period)
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          wf "Test becomes interactive.";
-          Option.value kiln_info_opt ~default:(wf "");
-          wf "Please type `q` to start a voting/protocol-change period.";
-        ]
-  in
-  let* _ =
-    wait_for_voting_period
-      state
-      ~protocol
-      ~client:client_0
-      ~attempts:waiting_attempts
-      `Proposal
-      ~level_within_period:3
-  in
-  let submit_prop acc client hash =
-    let* _ =
-      Tezos_client.successful_client_cmd
-        state
-        ~client
-        [
-          "submit";
-          "proposals";
-          "for";
-          Tezos_protocol.Account.name acc;
-          hash;
-          "--force";
-        ]
-    in
-    Console.sayf
-      state
-      Fmt.(
-        fun ppf () ->
-          pf ppf "%s voted for %s" (Tezos_protocol.Account.name acc) hash)
-  in
-  let* () =
-    List_sequential.iter keys_and_daemons ~f:(fun (acc, client, _) ->
-        submit_prop acc client new_protocol_hash)
-  in
-  let make_dummy_protocol_hashes t tag =
-    List.map
-      (List.init extra_dummy_proposals_batch_size ~f:(fun s ->
-           sprintf "proto-%s-%d" tag s))
-      ~f:(fun s ->
-        (t, Tezos_crypto.Protocol_hash.(hash_string [s] |> to_b58check)))
-  in
-  let extra_dummy_protocols =
-    List.bind extra_dummy_proposals_batch_levels ~f:(fun l ->
-        make_dummy_protocol_hashes l (sprintf "%d" l))
-  in
-  let* () =
-    Console.say
-      state
-      EF.(
-        wf
-          "Going to also vote for %s"
-          (String.concat ~sep:", " (List.map extra_dummy_protocols ~f:snd)))
-  in
-  let* () =
-    List_sequential.iteri
-      extra_dummy_protocols
-      ~f:(fun nth (level, proto_hash) ->
-        match List.nth keys_and_daemons (nth / 19) with
-        | None ->
-            failf "Too many dummy protocols Vs available voting power (%d)" nth
-        | Some (acc, client, _) ->
-            let* _ =
-              wait_for_voting_period
-                state
-                ~protocol
-                ~client:client_0
-                ~attempts:waiting_attempts
-                `Proposal
-                ~level_within_period:level
-            in
-            submit_prop acc client proto_hash)
-  in
-  let* _ =
-    wait_for_voting_period
-      state
-      ~protocol
-      ~client:client_0
-      ~attempts:waiting_attempts
-      `Exploration
-  in
-  let* () =
-    List_sequential.iter keys_and_daemons ~f:(fun (acc, client, _) ->
-        let* _ =
-          Tezos_client.successful_client_cmd
-            state
-            ~client
-            [
-              "submit";
-              "ballot";
-              "for";
-              Tezos_protocol.Account.name acc;
-              new_protocol_hash;
-              "yea";
-            ]
-        in
-        Console.sayf
-          state
-          Fmt.(
-            fun ppf () ->
-              pf
-                ppf
-                "%s voted Yea to test %s"
-                (Tezos_protocol.Account.name acc)
-                new_protocol_hash))
-  in
-  let* _ =
-    wait_for_voting_period
-      state
-      ~protocol
-      ~client:client_0
-      ~attempts:waiting_attempts
-      `Promotion
-  in
-  let protocol_switch_will_happen =
-    match test_variant with
-    | `Full_upgrade -> true
-    | `Nay_for_promotion -> false
-  in
-  let* () =
-    List_sequential.iter keys_and_daemons ~f:(fun (acc, client, _) ->
-        let* _ =
-          Tezos_client.successful_client_cmd
-            state
-            ~client
-            [
-              "submit";
-              "ballot";
-              "for";
-              Tezos_protocol.Account.name acc;
-              new_protocol_hash;
-              (if protocol_switch_will_happen then "yea" else "nay");
-            ]
-        in
-        Console.sayf
-          state
-          Fmt.(
-            fun ppf () ->
-              pf
-                ppf
-                "%s voted Yea to promote %s"
-                (Tezos_protocol.Account.name acc)
-                new_protocol_hash))
-  in
-  let* _ =
-    wait_for_voting_period
-      state
-      ~protocol
-      ~client:client_0
-      ~attempts:waiting_attempts
-      `Proposal
-  in
-  let* res =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:client_0
-      ["show"; "voting"; "period"]
-  in
-  let protocol_to_wait_for =
-    if protocol_switch_will_happen then new_protocol_hash
-    else protocol.Tezos_protocol.hash
-  in
-  let* () =
-    Helpers.wait_for state ~attempts:waiting_attempts ~seconds:4. (fun _ ->
-        let* () =
-          Console.say state EF.(wf "Checking actual protocol transition")
-        in
-        let* json =
-          Tezos_client.rpc
-            state
-            ~client:client_0
-            `Get
-            ~path:"/chains/main/blocks/head/metadata"
-        in
-        let* proto_hash =
-          try Jqo.field ~k:"protocol" json |> Jqo.get_string |> return
-          with e -> failf "Cannot parse metadata: %s" (Exn.to_string e)
-        in
-        if not (String.equal proto_hash protocol_to_wait_for) then
-          return
-            (`Not_done
-              (sprintf
-                 "Protocol not done: %s Vs %s"
-                 proto_hash
-                 protocol_to_wait_for))
-        else return (`Done ()))
-  in
-  Interactive_test.Pauser.generic
-    state
-    EF.
-      [
-        wf
-          "Test finished, protocol is now %s, things should keep baking."
-          protocol_to_wait_for;
-        markdown_verbatim (String.concat ~sep:"\n" res#out);
-      ]
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"daemons-upgrade"
-      ()
-  in
-  let docs = Manpage_builder.section_test_scenario base_state in
-  let variants =
-    [
-      ( "full-upgrade",
-        `Full_upgrade,
-        "Go through the whole voting process and do the protocol change." );
-      ( "nay-for-promotion",
-        `Nay_for_promotion,
-        "Go through the whole voting process but vote Nay at the last period \
-         and hence stay on the same protocol." );
-    ]
-  in
-  let term =
-    const
-      (fun
-        size
-        base_port
-        (`Attempts waiting_attempts)
-        (`External_peers external_peer_ports)
-        (`No_daemons_for no_daemons_for)
-        protocol
-        node_exec
-        client_exec
-        admin_exec
-        first_baker_exec
-        first_endorser_exec
-        first_accuser_exec
-        second_baker_exec
-        second_endorser_exec
-        second_accuser_exec
-        (`Protocol_path new_protocol_path)
-        (`Extra_dummy_proposals_batch_size extra_dummy_proposals_batch_size)
-        (`Extra_dummy_proposals_batch_levels extra_dummy_proposals_batch_levels)
-        generate_kiln_config
-        test_variant
-        state
-      ->
-        let actual_test =
-          run
-            state
-            ~size
-            ~base_port
-            ~protocol
-            ~node_exec
-            ~client_exec
-            ~first_baker_exec
-            ~first_endorser_exec
-            ~first_accuser_exec
-            ~second_baker_exec
-            ~second_endorser_exec
-            ~second_accuser_exec
-            ~admin_exec
-            ?generate_kiln_config
-            ~external_peer_ports
-            ~no_daemons_for
-            ~new_protocol_path
-            test_variant
-            ~waiting_attempts
-            ~extra_dummy_proposals_batch_size
-            ~extra_dummy_proposals_batch_levels
-        in
-        Test_command_line.Run_command.or_hard_fail
-          state
-          ~pp_error
-          (Interactive_test.Pauser.run_test ~pp_error state actual_test))
-    $ Arg.(
-        value & opt int 5
-        & info ["size"; "S"] ~docs ~doc:"Set the size of the network.")
-    $ Arg.(
-        value & opt int 20_000
-        & info ["base-port"; "P"] ~docs ~doc:"Base port number to build upon.")
-    $ Arg.(
-        const (fun n -> `Attempts n)
-        $ value
-            (opt
-               int
-               60
-               (info
-                  ["waiting-attempts"]
-                  ~docs
-                  ~doc:
-                    "Number of attempts done while waiting for voting periods")))
-    $ Arg.(
-        const (fun l -> `External_peers l)
-        $ value
-            (opt_all
-               int
-               []
-               (info
-                  ["add-external-peer-port"]
-                  ~docv:"PORT-NUMBER"
-                  ~docs
-                  ~doc:"Add $(docv) to the peers of the network nodes.")))
-    $ Arg.(
-        const (fun l -> `No_daemons_for l)
-        $ value
-            (opt_all
-               string
-               []
-               (info
-                  ["no-daemons-for"]
-                  ~docv:"ACCOUNT-NAME"
-                  ~docs
-                  ~doc:"Do not start daemons for $(docv).")))
-    $ Tezos_protocol.cli_term base_state
-    $ Tezos_executable.cli_term base_state `Node "tezos"
-    $ Tezos_executable.cli_term base_state `Client "tezos"
-    $ Tezos_executable.cli_term base_state `Admin "tezos"
-    $ Tezos_executable.cli_term base_state `Baker "first"
-    $ Tezos_executable.cli_term base_state `Endorser "first"
-    $ Tezos_executable.cli_term base_state `Accuser "first"
-    $ Tezos_executable.cli_term base_state `Baker "second"
-    $ Tezos_executable.cli_term base_state `Endorser "second"
-    $ Tezos_executable.cli_term base_state `Accuser "second"
-    $ Arg.(
-        const (fun p -> `Protocol_path (Caml.Filename.dirname p))
-        $ required
-            (pos
-               0
-               (some string)
-               None
-               (info
-                  []
-                  ~docs
-                  ~doc:"The protocol to inject and vote on."
-                  ~docv:"PROTOCOL-PATH")))
-    $ Arg.(
-        const (fun l -> `Extra_dummy_proposals_batch_size l)
-        $ value
-            (opt
-               int
-               0
-               (info
-                  ~docs
-                  ["extra-dummy-proposals-batch-size"]
-                  ~docv:"NUMBER"
-                  ~doc:"Submit $(docv) extra proposals per batch.")))
-    $ Arg.(
-        const (fun x -> `Extra_dummy_proposals_batch_levels x)
-        $ value
-            (opt
-               (list ~sep:',' int)
-               []
-               (info
-                  ["extra-dummy-proposals-batch-levels"]
-                  ~docs
-                  ~docv:"NUMBER"
-                  ~doc:
-                    "Set the levels within the proposal period where batches \
-                     of extra proposals appear, e.g. `3,5,7`.")))
-    $ Kiln.Configuration_directory.cli_term base_state
-    $ Arg.(
-        let doc =
-          sprintf
-            "Which variant of the test to run (one of {%s})"
-            (List.map ~f:(fun (n, _, _) -> n) variants
-            |> String.concat ~sep:", ")
-        in
-        value
-          (opt
-             (enum (List.map variants ~f:(fun (n, v, _) -> (n, v))))
-             `Full_upgrade
-             (info ~docs ["test-variant"] ~doc)))
-    $ Test_command_line.cli_state ~name:"daemons-upgrade" ()
-  in
-  let info =
-    let doc =
-      "Vote and Protocol-upgrade with bakers, endorsers, and accusers."
-    in
-    let man : Manpage.block list =
-      [
-        `S "DAEMONS-UPGRADE TEST";
-        `P
-          "This test builds and runs a sandbox network to do a full voting \
-           round followed by a protocol change while all the daemons.";
-        `P
-          (sprintf
-             "There are for now %d variants (see option `--test-variant`):"
-             (List.length variants));
-        `Blocks
-          (List.concat_map variants ~f:(fun (n, _, desc) ->
-               [`Noblank; `P (sprintf "* `%s`: %s" n desc)]));
-        `P "The test is interactive-only:";
-        `Blocks
-          (List.concat_mapi
-             ~f:(fun i s -> [`Noblank; `P (sprintf "%d) %s" (i + 1) s)])
-             [
-               "It starts a sandbox assuming the protocol of the `--first-*` \
-                executables (use the `--protocol-hash` option to make sure it \
-                matches).";
-               "An interactive pause is done to let the user play with the \
-                `first` protocol.";
-               "Once the user quits the prompt (`q` or `quit` command), a full \
-                voting round happens with a single proposal: the one at \
-                `PROTOCOL-PATH` (which should be the one understood by the \
-                `--second-*` executables).";
-               "Once the potential protocol switch has happened (and been \
-                verified), the test re-enters an interactive prompt to let the \
-                user play with the protocol (the first or second one, \
-                depending on the `--test-variant` option).";
-             ]);
-      ]
-    in
-    Cmd.info "daemons-upgrade" ~man ~doc
-  in
-  Cmd.v info term
diff --git a/src/bin_sandbox/command_ledger_baking.ml b/src/bin_sandbox/command_ledger_baking.ml
deleted file mode 100644
index 82706bcbfdcccbccc4d8e18e63bc84f68c240983..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_ledger_baking.ml
+++ /dev/null
@@ -1,649 +0,0 @@
-open Flextesa
-open Internal_pervasives
-
-let failf fmt = ksprintf (fun s -> fail (`Scenario_error s)) fmt
-
-let ledger_prompt_notice state ~ef ?(button = `Checkmark) () =
-  let button_str =
-    match button with
-    | `Checkmark -> "✔"
-    | `X -> "❌"
-    | `Both -> "❌ and ✔ at the same time"
-  in
-  Console.say
-    state
-    EF.(
-      desc
-        (shout "Ledger-prompt")
-        (list [ef; wf "Press %s on the ledger." button_str]))
-
-let assert_failure state msg f =
-  let* () = Console.say state EF.(wf "Asserting %s" msg) in
-  let* result =
-    Asynchronous_result.bind_on_error
-      (let* _ = f () in
-       return `Worked)
-      ~f:(fun ~result:_ _ -> return `Didn'tWork)
-  in
-  match result with `Worked -> failf "%s" msg | `Didn'tWork -> return ()
-
-let failf fmt = ksprintf (fun s -> fail (`Scenario_error s)) fmt
-
-let assert_ a = if a then return () else failf "Assertion failed"
-
-let assert_eq to_string ~expected ~actual =
-  if Poly.equal expected actual then return ()
-  else
-    failf
-      "Assertion failed: expected %s but got %s"
-      (to_string expected)
-      (to_string actual)
-
-let rec ask state ef =
-  let* () = Console.say state EF.(list [ef; wf " (y/n)?"]) in
-  let* char = System_error.catch Lwt_io.read_char Lwt_io.stdin in
-  match char with
-  | 'y' | 'Y' -> return true
-  | 'n' | 'N' -> return false
-  | _ -> ask state ef
-
-let ask_assert state ef =
-  let* asked = ask state ef in
-  assert_ asked
-
-let with_ledger_prompt state message expectation ~f =
-  let* () =
-    ledger_prompt_notice
-      state
-      ()
-      ~button:(match expectation with `Succeeds -> `Checkmark | `Fails -> `X)
-      ~ef:
-        EF.(
-          list
-            [
-              message;
-              wf "\n\n";
-              wf
-                (match expectation with
-                | `Succeeds -> ">> ACCEPT THIS <<"
-                | `Fails -> ">> REJECT THIS <<");
-            ])
-  in
-  match expectation with
-  | `Succeeds ->
-      let* _ = f () in
-      Console.say state EF.(wf "> Got response: ACCEPTED")
-  | `Fails ->
-      let* () = assert_failure state "expected failure" f in
-      Console.say state EF.(wf "> Got response: REJECTED")
-
-let with_ledger_test_reject_and_succeed state ef f =
-  let* () = with_ledger_prompt state ef `Fails ~f in
-  with_ledger_prompt state ef `Succeeds ~f
-
-let assert_hwms state ~client ~uri ~main ~test =
-  let* () =
-    Console.say
-      state
-      EF.(wf "Asserting main HWM = %d and test HWM = %d" main test)
-  in
-  let* {main = main_actual; test = test_actual; _} =
-    Tezos_client.Ledger.get_hwm state ~client ~uri
-  in
-  let* () = assert_eq Int.to_string ~actual:main_actual ~expected:main in
-  assert_eq Int.to_string ~actual:test_actual ~expected:test
-
-let get_chain_id_string state ~client =
-  let* json =
-    Tezos_client.rpc state ~client `Get ~path:"/chains/main/chain_id"
-  in
-  match json with
-  | `String x -> return x
-  | _ -> failf "Failed to parse chain_id JSON from node"
-
-let get_chain_id state ~client =
-  let* chain_id_string = get_chain_id_string state ~client in
-  return (Tezos_crypto.Chain_id.of_b58check_exn chain_id_string)
-
-let get_head_block_hash state ~client () =
-  let* json =
-    Tezos_client.rpc state ~client `Get ~path:"/chains/main/blocks/head/hash"
-  in
-  match json with
-  | `String x -> return x
-  | _ -> failf "Failed to parse block hash JSON from node"
-
-let forge_endorsement state ~client ~chain_id ~level =
-  let* branch = get_head_block_hash state ~client () in
-  let json =
-    `O
-      [
-        ("branch", `String branch);
-        ( "contents",
-          `A
-            [
-              `O
-                [
-                  ("kind", `String "endorsement");
-                  ("level", `Float (Float.of_int level));
-                ];
-            ] );
-      ]
-  in
-  let* json =
-    Tezos_client.rpc
-      state
-      ~client
-      ~path:"/chains/main/blocks/head/helpers/forge/operations"
-      (`Post (Ezjsonm.to_string json))
-  in
-  match json with
-  | `String operation_bytes ->
-      let endorsement_magic_byte = "02" in
-      return
-        (endorsement_magic_byte
-        ^ (chain_id |> Tezos_crypto.Chain_id.to_hex |> Hex.show)
-        ^ operation_bytes)
-  | _ -> failf "Failed to forge operation or parse result"
-
-let forge_delegation state ~client ~src ~dest ?(fee = 0.00126) () =
-  let* branch = get_head_block_hash state ~client () in
-  let json =
-    `O
-      [
-        ("branch", `String branch);
-        ( "contents",
-          `A
-            [
-              `O
-                [
-                  ("kind", `String "delegation");
-                  ("source", `String src);
-                  ( "fee",
-                    `String (Int.to_string (Int.of_float (fee *. 1000000.))) );
-                  ("counter", `String (Int.to_string 30713));
-                  ("gas_limit", `String (Int.to_string 10100));
-                  ("delegate", `String dest);
-                  ("storage_limit", `String (Int.to_string 277));
-                ];
-            ] );
-      ]
-  in
-  let* json =
-    Tezos_client.rpc
-      state
-      ~client
-      ~path:"/chains/main/blocks/head/helpers/forge/operations"
-      (`Post (Ezjsonm.to_string json))
-  in
-  match json with
-  | `String operation_bytes ->
-      let magic_byte = "03" in
-      return (magic_byte ^ operation_bytes)
-  | _ -> failf "Failed to forge operation or parse result"
-
-let sign state ~client ~bytes () =
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:client.Tezos_client.Keyed.client
-      ["sign"; "bytes"; "0x" ^ bytes; "for"; client.Tezos_client.Keyed.key_name]
-  in
-  return ()
-
-let originate_account_from state ~client ~account =
-  let orig_account_name = "-originated-account" in
-  let id_script parameter =
-    Fmt.str
-      "parameter %s;\n\
-       storage %s;\n\
-       code\n\
-      \  {\n\
-      \    %s\n\
-      \    { CAR; NIL operation; PAIR }\n\
-      \  };\n"
-      parameter
-      parameter
-      "# No push-drops"
-  in
-  let tmp = Caml.Filename.temp_file "little-id-script" ".tz" in
-  let* () = System.write_file state tmp ~content:(id_script "unit") in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client
-      [
-        "originate";
-        "contract";
-        orig_account_name;
-        "transferring";
-        Int.to_string 1000;
-        "from";
-        Tezos_protocol.Account.pubkey_hash account;
-        "running";
-        tmp;
-        "--init";
-        "Unit";
-        "--burn-cap";
-        Float.to_string 0.300;
-      ]
-  in
-  return orig_account_name
-
-let setup_baking_ledger state uri ~client ~protocol =
-  let* () = Console.say state EF.(wf "Setting up the ledger device %S" uri) in
-  let key_name = "ledgered" in
-  let baker = Tezos_client.Keyed.make client ~key_name ~secret_key:uri in
-  let assert_baking_key x =
-    let to_string = function Some x -> x | None -> "<none>" in
-    let* () =
-      Console.say
-        state
-        EF.(wf "Asserting that the authorized key is %s" (to_string x))
-    in
-    let* auth_key = Tezos_client.Ledger.get_authorized_key state ~client ~uri in
-    assert_eq to_string ~expected:x ~actual:auth_key
-  in
-  let* () =
-    Tezos_client.Ledger.deauthorize_baking state ~client ~uri
-    (* TODO: The following assertion doesn't confirm anything if the ledger was already not authorized to bake. *)
-  in
-  let* () = assert_baking_key None in
-  let* account = Tezos_client.Ledger.show_ledger state ~client ~uri in
-  let* () =
-    with_ledger_test_reject_and_succeed
-      state
-      EF.(
-        wf
-          "Importing %S in client `%s`. The ledger should be prompting for \
-           acknowledgment to provide the public key of %s"
-          uri
-          client.Tezos_client.id
-          (Tezos_protocol.Account.pubkey_hash account))
-      (fun () ->
-        let* _ = Tezos_client.Keyed.initialize state baker in
-        return ())
-  in
-  let* () =
-    assert_failure state "baking before setup should fail" (fun () ->
-        Tezos_client.Keyed.bake state baker "Baked by ledger")
-  in
-  let* () =
-    assert_failure state "endorsing before setup should fail" (fun () ->
-        Tezos_client.Keyed.endorse state baker "Endorsed by ledger")
-  in
-  let test_invalid_delegations () =
-    let ledger_pkh = Tezos_protocol.Account.pubkey_hash account in
-    let other_pkh =
-      Tezos_protocol.Account.pubkey_hash
-        (fst (List.last_exn protocol.Tezos_protocol.bootstrap_accounts))
-    in
-    let cases =
-      [
-        (ledger_pkh, other_pkh, "ledger to another account");
-        (other_pkh, ledger_pkh, "another account to ledger");
-        (other_pkh, other_pkh, "another account to another account");
-      ]
-    in
-    List_sequential.iter cases ~f:(fun (src, dest, msg) ->
-        let* forged_delegation_bytes =
-          forge_delegation state ~client ~src ~dest ()
-        in
-        assert_failure
-          state
-          (sprintf
-             "signing a delegation from %s (%s to %s) should fail"
-             msg
-             src
-             dest)
-          (sign state ~client:baker ~bytes:forged_delegation_bytes))
-  in
-  let* () = test_invalid_delegations () in
-  let* cid = get_chain_id_string state ~client in
-  let* () =
-    with_ledger_test_reject_and_succeed
-      state
-      EF.(
-        list
-          [
-            wf "Setting up %S for baking" uri;
-            wf "Setup Baking?";
-            wf "Address: %S\n" (Tezos_protocol.Account.pubkey_hash account);
-            wf "Chain: %S" cid;
-            wf "Main Chain HWM: 0";
-            wf "Test Chain HWM: 0";
-          ])
-      (fun () ->
-        Tezos_client.successful_client_cmd
-          state
-          ~client
-          [
-            "setup";
-            "ledger";
-            "to";
-            "bake";
-            "for";
-            key_name;
-            "--main-hwm";
-            "0";
-            "--test-hwm";
-            "0";
-          ])
-  in
-  let* () = assert_baking_key (Some uri) in
-  let* () = test_invalid_delegations () in
-  return (baker, account)
-
-let run state ~protocol ~node_exec ~client_exec ~admin_exec ~size ~base_port
-    ~uri ~enable_deterministic_nonce_tests () =
-  let* () = Helpers.clear_root state in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Ready to start"; af "Root path deleted."]
-  in
-  let ledger_client = Tezos_client.no_node_client ~exec:client_exec in
-  let* ledger_account =
-    Tezos_client.Ledger.show_ledger state ~client:ledger_client ~uri
-  in
-  let protocol =
-    let open Tezos_protocol in
-    {
-      protocol with
-      time_between_blocks = [1; 2];
-      minimal_block_delay = 1;
-      bootstrap_accounts =
-        (ledger_account, 1_000_000_000_000L) :: protocol.bootstrap_accounts;
-    }
-  in
-  let other_baker_account =
-    fst (List.nth_exn protocol.Tezos_protocol.bootstrap_accounts 1)
-  in
-  let* nodes, protocol =
-    Test_scenario.network_with_protocol
-      ~protocol
-      ~size
-      ~base_port
-      state
-      ~node_exec
-      ~client_exec
-  in
-  let make_admin = Tezos_admin_client.of_client ~exec:admin_exec in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes
-      @ [secret_keys state ~protocol; Log_recorder.Operations.show_all state]
-      @ arbitrary_commands_for_each_and_all_clients
-          state
-          ~make_admin
-          ~clients:(List.map nodes ~f:(Tezos_client.of_node ~exec:client_exec))) ;
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "About to really start playing"]
-  in
-  let client n =
-    Tezos_client.of_node ~exec:client_exec (List.nth_exn nodes n)
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:(client 0)
-      Tezos_protocol.Account.
-        [
-          "import";
-          "secret";
-          "key";
-          name other_baker_account;
-          private_key other_baker_account;
-        ]
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:(client 0)
-      Tezos_protocol.Account.["bake"; "for"; name other_baker_account]
-  in
-  let assert_hwms_ ~main ~test =
-    assert_hwms state ~client:(client 0) ~uri ~main ~test
-  in
-  let set_hwm_ level =
-    with_ledger_prompt
-      state
-      EF.(list [wf "Reset HWM"; wf "%d" level])
-      `Succeeds
-      ~f:(fun () ->
-        Tezos_client.Ledger.set_hwm state ~client:(client 0) ~uri ~level)
-  in
-  let* chain_id = get_chain_id state ~client:(client 0) in
-  let* baker, ledger_account =
-    setup_baking_ledger state uri ~client:(client 0) ~protocol
-  in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.
-      [
-        arbitrary_command_on_all_clients
-          state
-          ~command_names:["baker"]
-          ~make_admin
-          ~clients:[baker.Tezos_client.Keyed.client];
-      ] ;
-  let bake () = Tezos_client.Keyed.bake state baker "Baked by ledger" in
-  let endorse () =
-    Tezos_client.Keyed.endorse state baker "Endorsed by ledger"
-  in
-  let* cid = get_chain_id_string state ~client:(client 0) in
-  let ask_hwm ~main ~test =
-    let* () = assert_hwms_ ~main ~test in
-    ask_assert
-      state
-      EF.(wf "Is 'Chain' = %S and 'Last Block Level' = %d" cid main)
-  in
-  let* () =
-    if enable_deterministic_nonce_tests then
-      (* Test determinism of nonces *)
-      let* thisNonce1 = Tezos_client.Keyed.generate_nonce state baker "this" in
-      let* thatNonce1 = Tezos_client.Keyed.generate_nonce state baker "that" in
-      let* thisNonce2 = Tezos_client.Keyed.generate_nonce state baker "this" in
-      let* thatNonce2 = Tezos_client.Keyed.generate_nonce state baker "that" in
-      let* () =
-        assert_eq (fun x -> x) ~expected:thisNonce1 ~actual:thisNonce2
-      in
-      let* () =
-        assert_eq (fun x -> x) ~expected:thatNonce1 ~actual:thatNonce2
-      in
-      assert_ Poly.(thisNonce1 <> thatNonce1)
-    else return ()
-  in
-  let* () =
-    assert_failure
-      state
-      "originating an account from the Tezos Baking app should fail"
-      (fun () ->
-        let* _ =
-          originate_account_from
-            state
-            ~client:(client 0)
-            ~account:ledger_account
-        in
-        return ())
-  in
-  let fee = 0.00126 in
-  let ledger_pkh = Tezos_protocol.Account.pubkey_hash ledger_account in
-  let* forged_delegation_bytes =
-    forge_delegation
-      state
-      ~client:(client 0)
-      ()
-      ~src:ledger_pkh
-      ~dest:ledger_pkh
-      ~fee
-  in
-  let* () =
-    with_ledger_test_reject_and_succeed
-      state
-      EF.(
-        list
-          [
-            wf "Register as delegate?";
-            wf "Address %s" ledger_pkh;
-            wf "Fee %f" fee;
-          ])
-      (sign state ~client:baker ~bytes:forged_delegation_bytes)
-  in
-  let* () = bake () in
-  let* () = ask_hwm ~main:3 ~test:0 in
-  let* () =
-    let level = 1 in
-    with_ledger_test_reject_and_succeed
-      state
-      EF.(list [wf "Reset HWM"; wf "%d" level])
-      (fun () ->
-        Tezos_client.Ledger.set_hwm state ~client:(client 0) ~uri ~level)
-  in
-  let* () = assert_hwms_ ~main:1 ~test:1 in
-  let* () = bake () in
-  let* () = assert_hwms_ ~main:4 ~test:1 in
-  let* () = set_hwm_ 5 in
-  let* () = assert_hwms_ ~main:5 ~test:5 in
-  let* () =
-    assert_failure state "endorsing a level beneath HWM should fail" endorse
-  in
-  let* () =
-    assert_failure state "baking a level beneath HWM should fail" bake
-  in
-  let* () = set_hwm_ 4 in
-  let* () = bake () in
-  let* () = assert_hwms_ ~main:5 ~test:4 in
-  let* () = endorse () (* does not increase level since we just baked *) in
-  let* () =
-    assert_failure state "endorsing same block twice should not work" endorse
-  in
-  let* () = assert_hwms_ ~main:5 ~test:4 in
-  let* () = bake () in
-  let* () = assert_hwms_ ~main:6 ~test:4 in
-  let* endorsement_at_low_level_bytes =
-    forge_endorsement state ~client:baker.client ~chain_id ~level:1
-  in
-  let* () =
-    assert_failure
-      state
-      "endorsing-after-baking a level beneath HWM should fail"
-      (sign state ~client:baker ~bytes:endorsement_at_low_level_bytes)
-  in
-  let* () = assert_hwms_ ~main:6 ~test:4 (* HWM has not changed *) in
-  let* () = endorse () (* HWM still has not changed *) in
-  let* () =
-    assert_hwms_ ~main:6 ~test:4 (* Forge an endorsement on a different chain *)
-  in
-  let other_chain_id = "NetXSzLHKwSumh7" in
-  let* () =
-    Console.say
-      state
-      EF.(
-        wf
-          "Signing a forged endorsement on a different chain: %s"
-          other_chain_id)
-  in
-  let* endorsement_on_different_chain_bytes =
-    forge_endorsement
-      state
-      ~client:baker.client
-      ~chain_id:(Tezos_crypto.Chain_id.of_b58check_exn other_chain_id)
-      ~level:5
-  in
-  let* () =
-    sign state ~client:baker ~bytes:endorsement_on_different_chain_bytes ()
-    (* Only the test HWM has changed *)
-  in
-  let* () = assert_hwms_ ~main:6 ~test:5 in
-  let* () = Loop.n_times 5 (fun _ -> bake ()) in
-  let* () = ask_hwm ~main:11 ~test:5 in
-  let* () =
-    Tezos_client.Ledger.deauthorize_baking state ~client:(client 0) ~uri
-  in
-  let* () =
-    assert_failure state "baking after deauthorization should fail" bake
-  in
-  assert_failure state "endorsing after deauthorization should fail" endorse
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"ledger-baking"
-      ()
-  in
-  let docs = Manpage_builder.section_test_scenario base_state in
-  let term =
-    const
-      (fun
-        uri
-        node_exec
-        client_exec
-        admin_exec
-        size
-        (`Base_port base_port)
-        no_deterministic_nonce_tests
-        protocol
-        state
-      ->
-        Test_command_line.Run_command.or_hard_fail
-          state
-          ~pp_error
-          (Interactive_test.Pauser.run_test
-             ~pp_error
-             state
-             (run
-                state
-                ~protocol
-                ~node_exec
-                ~size
-                ~admin_exec
-                ~base_port
-                ~client_exec
-                ~enable_deterministic_nonce_tests:
-                  (not no_deterministic_nonce_tests)
-                ~uri)))
-    $ Arg.(
-        required
-          (pos
-             0
-             (some string)
-             None
-             (info [] ~docv:"LEDGER-URI" ~doc:"ledger:// URI")))
-    $ Tezos_executable.cli_term base_state `Node "tezos"
-    $ Tezos_executable.cli_term base_state `Client "tezos"
-    $ Tezos_executable.cli_term base_state `Admin "tezos"
-    $ Arg.(
-        value (opt int 5 (info ["size"; "S"] ~docs ~doc:"Size of the Network")))
-    $ Arg.(
-        const (fun p -> `Base_port p)
-        $ value
-            (opt
-               int
-               46_000
-               (info
-                  ["base-port"; "P"]
-                  ~docs
-                  ~doc:"Base port number to build upon")))
-    $ Arg.(
-        value
-          (flag
-             (info
-                ["no-deterministic-nonce-tests"]
-                ~docs
-                ~doc:"Disable tests for deterministic nonces")))
-    $ Tezos_protocol.cli_term base_state
-    $ Test_command_line.cli_state ~name:"ledger-baking" ()
-  in
-  let info =
-    let doc = "Interactive test exercising the Ledger Baking app features" in
-    Cmd.info ~doc "ledger-baking"
-  in
-  Cmd.v info term
diff --git a/src/bin_sandbox/command_ledger_wallet.ml b/src/bin_sandbox/command_ledger_wallet.ml
deleted file mode 100644
index 013b3945828103b70d65354b58fa522ffb4f1a43..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_ledger_wallet.ml
+++ /dev/null
@@ -1,1728 +0,0 @@
-open Flextesa
-open Internal_pervasives
-
-(********************* TEST UTILS **********************)
-
-let client_async_cmd state ~client args ~f =
-  let* status, res =
-    Running_processes.Async.run_cmdf
-      ~id_base:"client_async_cmd"
-      state
-      ~f
-      "sh -c %s"
-      (Tezos_client.client_command state client args
-      |> Genspio.Compile.to_one_liner |> Caml.Filename.quote)
-  in
-  return
-    (object
-       method out = fst res
-
-       method err = snd res
-
-       method status = status
-     end
-      : Process_result.t)
-
-let ledger_hash_re =
-  lazy
-    Re.(
-      compile
-        (seq
-           [
-             str "* Blake 2B Hash (ledger-style, with operation watermark):";
-             rep1 (alt [space; eol]);
-             group (rep1 alnum);
-             rep1 (alt [space; eol]);
-           ]))
-
-(* Searches a stream for an expected ledger hash from `tezos-client --verbose-signing`*)
-let find_and_print_signature_hash ?(display_expectation = true) state process =
-  let re = Lazy.force ledger_hash_re in
-  let check lines =
-    Re.(
-      match exec_opt re lines with
-      | None -> None
-      | Some matches -> Some (Group.get matches 1))
-  in
-  (* Dbg.e EF.(wf "find_and_print_signature_hash") ; *)
-  let* output, error, _ =
-    Running_processes.Async.fold_process
-      process
-      ~init:("", "", not display_expectation)
-      ~f:(fun (all_output_prev, all_error_prev, showed_message_prev) out err ->
-        (* Dbg.e EF.(wf "find_and_print_signature_hash.fold_process %S %S" out err) ; *)
-        let all_output = all_output_prev ^ out in
-        let all_error = all_error_prev ^ err in
-        let* showed_message =
-          if not showed_message_prev then
-            match check all_output with
-            | None -> return false
-            | Some x ->
-                let* () =
-                  Console.say state EF.(wf "Displayed hash should be: `%s`" x)
-                in
-                return true
-          else return true
-        in
-        return (`Continue (all_output, all_error, showed_message)))
-  in
-  return (String.split ~on:'\n' output, String.split ~on:'\n' error)
-
-module MFmt = More_fmt
-
-let failf ?attach fmt = ksprintf (fun s -> fail ?attach (`Scenario_error s)) fmt
-
-let ledger_prompt_notice state ~msgs ?(button = `Checkmark) () =
-  let button_str =
-    match button with
-    | `Checkmark -> "✔"
-    | `X -> "❌"
-    | `Both -> "❌ and ✔ at the same time"
-  in
-  Console.sayf
-    state
-    MFmt.(
-      fun ppf () ->
-        vertical_box ~indent:4 ppf (fun ppf ->
-            shout ppf (fun ppf -> const string "Ledger-prompt:" ppf ()) ;
-            cut ppf () ;
-            List.iter msgs ~f:(fun f ->
-                f ppf () ;
-                cut ppf ()) ;
-            wf ppf "→ Press %s on the ledger." button_str))
-
-let ledger_prompt_notice_expectation state ~messages ~user_answer =
-  ledger_prompt_notice
-    state
-    ()
-    ~button:(match user_answer with `Accept -> `Checkmark | `Reject -> `X)
-    ~msgs:
-      (messages
-      @ MFmt.
-          [
-            cut;
-            (fun ppf () ->
-              match user_answer with
-              | `Accept -> shout ppf (fun ppf -> pf ppf ">> ACCEPT THIS <<")
-              | `Reject -> shout ppf (fun ppf -> pf ppf ">> REJECT THIS <<"));
-          ])
-
-let with_ledger_test_reject_and_accept ?(only_success = false) state ~messages f
-    =
-  let with_ledger_prompt state ~messages ~user_answer ~f =
-    let* () = ledger_prompt_notice_expectation state ~messages ~user_answer in
-    f ~user_answer
-  in
-  let* () =
-    if only_success then return ()
-    else with_ledger_prompt state ~messages ~user_answer:`Reject ~f
-  in
-  with_ledger_prompt state ~messages ~user_answer:`Accept ~f
-
-let get_chain_id state ~client =
-  let* chain_id_string =
-    let* json =
-      Tezos_client.rpc state ~client `Get ~path:"/chains/main/chain_id"
-    in
-    match json with
-    | `String x -> return x
-    | _ -> failf "Failed to parse chain_id JSON from node"
-  in
-  return (Tezos_crypto.Chain_id.of_b58check_exn chain_id_string)
-
-let get_head_block_hash state ~client () =
-  let* json =
-    Tezos_client.rpc state ~client `Get ~path:"/chains/main/blocks/head/hash"
-  in
-  match json with
-  | `String x -> return x
-  | _ -> failf "Failed to parse block hash JSON from node"
-
-let please_check_the_hash ppf () =
-  let open MFmt in
-  tag "prompt" ppf (fun ppf ->
-      wf ppf "The ledger cannot parse this operation, please verify the hash.")
-
-let expect_from_output ~expectation ~message (proc_res : Process_result.t) =
-  (* let expect_rejection msg (success, (stdout, stderr)) = *)
-  let exp =
-    match expectation with
-    | `Ledger_reject_or_timeout -> "rejection"
-    | `Not_a_delegate -> "not-delegate-error"
-    | `Success -> "success"
-    | `Origination_failed -> "origination-failure"
-  in
-  let nope s =
-    failf
-      ~attach:
-        [("stdout", `Verbatim proc_res#out); ("stderr", `Verbatim proc_res#err)]
-      "%s, expected %s: %s."
-      message
-      exp
-      s
-  in
-  let success = Poly.equal proc_res#status (Unix.WEXITED 0) in
-  match expectation with
-  | `Success when success -> return ()
-  | `Success -> nope "did not succeed"
-  | (`Ledger_reject_or_timeout | `Not_a_delegate | `Origination_failed) as e
-    -> (
-      let pattern =
-        match e with
-        | `Ledger_reject_or_timeout -> "Conditions of use not satisfied"
-        | `Not_a_delegate -> "not registered as valid delegate key"
-        | `Origination_failed -> "origination simulation failed"
-      in
-      let all_output = String.concat ~sep:"\n" (proc_res#out @ proc_res#err) in
-      match (success, String.substr_index all_output ~pattern) with
-      | false, Some _ -> return ()
-      | false, None -> nope "cannot find the right error message"
-      | true, _ -> nope "command succeeded??")
-
-(********************* TEST SECTIONS ***************************)
-
-let voting_tests state ~client ~src ~with_rejections ~protocol_kind
-    ~ledger_account ~tested_proposal ~go_to_next_period () =
-  let expect_failure message v =
-    expect_from_output ~expectation:`Not_a_delegate ~message v
-  in
-  let expect_rejection message v =
-    expect_from_output ~expectation:`Ledger_reject_or_timeout ~message v
-  in
-  let test_reject_and_accept name ~messages action =
-    let* () =
-      if with_rejections then
-        let* () =
-          ledger_prompt_notice_expectation state ~messages ~user_answer:`Reject
-        in
-        let* res = action () in
-        expect_rejection name res
-      else return ()
-    in
-    let* () =
-      ledger_prompt_notice_expectation state ~messages ~user_answer:`Accept
-    in
-    let* res = action () in
-    expect_failure name res
-  in
-  let source_display = Tezos_protocol.Account.pubkey_hash ledger_account in
-  let submit_proposals ~display_expectation proposals () =
-    client_async_cmd
-      state
-      ~client:(client 0)
-      ~f:(fun _ proc ->
-        find_and_print_signature_hash ~display_expectation state proc)
-      (["submit"; "proposals"; "for"; src]
-      @ proposals
-      @ ["--force"; "--verbose-signing"])
-  in
-  let* () =
-    test_reject_and_accept
-      "single-proposal"
-      ~messages:
-        MFmt.
-          [
-            (fun ppf () ->
-              wf ppf "Submitting single proposal %s" tested_proposal);
-            (fun ppf () ->
-              match protocol_kind with
-              | `Athens -> ()
-              | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada
-              | `Hangzhou | `Ithaca | `Jakarta | `Alpha ->
-                  wf
-                    ppf
-                    "From Babylon on, You will first be asked to provide the \
-                     public key." ;
-                  cut ppf () ;
-                  wf
-                    ppf
-                    "Accept this prompt, regardless of below, then continue.");
-            (fun ppf () ->
-              vertical_box ppf ~indent:4 (fun ppf ->
-                  wf
-                    ppf
-                    "Protocol is %a, the ledger should be able to display \
-                     voting parameters:"
-                    Tezos_protocol.Protocol_kind.pp
-                    protocol_kind ;
-                  cut ppf () ;
-                  wf ppf "* Confirm Proposal" ;
-                  cut ppf () ;
-                  wf ppf "* Source: `%s`" source_display ;
-                  cut ppf () ;
-                  wf ppf "* Period: `0`" ;
-                  cut ppf () ;
-                  wf ppf "* Protocol: `%s`" tested_proposal));
-          ]
-      (submit_proposals ~display_expectation:false [tested_proposal])
-  in
-  let* () =
-    test_reject_and_accept
-      "multiple-proposal"
-      ~messages:
-        MFmt.
-          [
-            (fun ppf () -> wf ppf "Submitting 2 proposals together");
-            please_check_the_hash;
-          ]
-      (submit_proposals
-         ~display_expectation:true
-         [
-           tested_proposal; "Psd1ynUBhMZAeajwcZJAeq5NrxorM6UCU4GJqxZ7Bx2e9vUWB6z";
-         ])
-  in
-  let* () = go_to_next_period () in
-  List_sequential.iter ["yea"; "nay"] ~f:(fun vote ->
-      let* _ =
-        Console.say state EF.(haf "EXPECTING THE NEXT COMMAND TO FAIL")
-      in
-      test_reject_and_accept
-        (Fmt.str "vote-%s" vote)
-        ~messages:
-          MFmt.
-            [
-              (fun ppf () ->
-                match protocol_kind with
-                | `Athens -> ()
-                | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada
-                | `Hangzhou | `Ithaca | `Jakarta | `Alpha ->
-                    wf
-                      ppf
-                      "From Babylon on, you will first be asked to provide the \
-                       public key." ;
-                    cut ppf () ;
-                    wf
-                      ppf
-                      "Accept this prompt, regardless of below, then continue.");
-              (fun ppf () -> wf ppf "Voting %s for %s" vote tested_proposal);
-              (fun ppf () -> wf ppf "Source: `%s`" source_display);
-              (fun ppf () -> wf ppf "Protocol: `%s`" tested_proposal);
-              (fun ppf () -> wf ppf "Period: `%i`" 1);
-            ]
-        (fun () ->
-          let* _, proc =
-            Tezos_client.client_cmd
-              state
-              ~client:(client 0)
-              ["submit"; "ballot"; "for"; src; tested_proposal; vote]
-          in
-          return proc))
-
-let ledger_should_display ?title ppf l =
-  let open MFmt in
-  vertical_box ~indent:4 ppf (fun ppf ->
-      wf ppf "Ledger should display:" ;
-      cut ppf () ;
-      (match title with None -> () | Some t -> wf ppf t) ;
-      List.iter l ~f:(fun (s, f) ->
-          cut ppf () ;
-          pf ppf "* %s: %a." s f ()))
-
-let show_command_message command =
-  MFmt.(
-    fun ppf () ->
-      wrapping_box ~indent:2 ppf (fun ppf ->
-          wf ppf "Command:" ;
-          sp ppf () ;
-          const
-            (list ~sep:sp string)
-            ("<tezos-client>" :: command |> List.map ~f:Caml.Filename.quote)
-            ppf
-            ()))
-
-let originate_manager_tz_script state ~client ~name ~from ~bake ~protocol_kind
-    ~ledger_account =
-  let prepare_origination_of_manager_tz_script ?(spendable = false)
-      ?(delegatable = false) ?delegate state ~name ~from ~protocol_kind
-      ~ledger_account =
-    let ledger_pkh = Tezos_protocol.Account.pubkey_hash ledger_account in
-    let manager_tz_script =
-      "\n\
-      \      parameter\n\
-      \        (or\n\
-      \           (lambda %do unit (list operation))\n\
-      \           (unit %default));\n\
-      \      storage key_hash;\n\
-      \      code\n\
-      \        { UNPAIR ;\n\
-      \          IF_LEFT\n\
-      \            { # 'do' entrypoint\n\
-      \              # Assert no token was sent:\n\
-      \              # to send tokens, the default entry point should be used\n\
-      \              PUSH mutez 0 ;\n\
-      \              AMOUNT ;\n\
-      \              ASSERT_CMPEQ ;\n\
-      \              # Assert that the sender is the manager\n\
-      \              DUUP ;\n\
-      \              IMPLICIT_ACCOUNT ;\n\
-      \              ADDRESS ;\n\
-      \              SENDER ;\n\
-      \              ASSERT_CMPEQ ;\n\
-      \              # Execute the lambda argument\n\
-      \              UNIT ;\n\
-      \              EXEC ;\n\
-      \              PAIR ;\n\
-      \            }\n\
-      \            { # 'default' entrypoint\n\
-      \              DROP ;\n\
-      \              NIL operation ;\n\
-      \              PAIR ;\n\
-      \            }\n\
-      \        };"
-    in
-    let tmp = Caml.Filename.temp_file "manager" ".tz" in
-    let* () = System.write_file state tmp ~content:manager_tz_script in
-    let origination =
-      let opt = Option.value_map ~default:[] in
-      ["--wait"; "none"; "originate"; "contract"; name]
-      @ (match protocol_kind with
-        | `Athens -> ["for"; from]
-        | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada
-        | `Hangzhou | `Ithaca | `Jakarta | `Alpha ->
-            [])
-      @ [
-          "transferring";
-          "350";
-          "from";
-          from;
-          "running";
-          tmp;
-          "--init";
-          sprintf "\"%s\"" ledger_pkh;
-          "--force";
-          "--burn-cap";
-          "300000000000";
-          (* ; "--fee-cap" ; "20000000000000" *)
-          "--gas-limit";
-          "1000000000000000";
-          "--storage-limit";
-          "20000000000000";
-          "--verbose-signing";
-        ]
-      @ opt delegate ~f:(fun s -> (* Baby & Aths *) ["--delegate"; s])
-      @ (if delegatable then [(* Aths *) "--delegatable"] else [])
-      @ if spendable then [(* Aths *) "--spendable"] else []
-    in
-    return origination
-  in
-  let* origination =
-    prepare_origination_of_manager_tz_script
-      state
-      ~name
-      ~from
-      ~protocol_kind
-      ~ledger_account
-  in
-  let* _ = Tezos_client.successful_client_cmd state ~client origination in
-  Fmt.kstr bake "baking `%s` in" name
-
-let manager_tz_delegation_tests state ~client ~ledger_key ~ledger_account
-    ~with_rejections ~protocol_kind ~delegate_pkh ~random_contract_pkh ~bake ()
-    =
-  let manager_tz_kt1_account = "manager-tz" in
-  let* () =
-    with_ledger_test_reject_and_accept
-      ~only_success:true
-      state
-      ~messages:
-        MFmt.
-          [
-            (fun ppf () -> wf ppf "Originating manager.tz contract ");
-            (fun ppf () -> wf ppf "Sign Hash");
-            (fun ppf () ->
-              wf
-                ppf
-                "The ledger should be prompting for acknowledgment to provide \
-                 a signature of an unknown operation. THIS IS NOT AN ACTUAL \
-                 TEST, and is only part of the test setup. There is no need \
-                 for a verification of this hash. Please accept this \
-                 Unrecognized Operation.");
-          ]
-      (fun ~user_answer:_ ->
-        originate_manager_tz_script
-          state
-          ~client
-          ~name:manager_tz_kt1_account
-          ~from:ledger_key
-          ~bake
-          ~protocol_kind
-          ~ledger_account)
-  in
-  let* _, proc_result =
-    Tezos_client.client_cmd
-      state
-      ~client
-      ["show"; "known"; "contract"; manager_tz_kt1_account]
-  in
-  let contract_address = proc_result#out |> String.concat ~sep:"" in
-  let ledger_pkh = Tezos_protocol.Account.pubkey_hash ledger_account in
-  let random_implicit_account =
-    Tezos_protocol.Account.of_name "random-account-for-manager-test"
-  in
-  let random_acc_pkh =
-    Tezos_protocol.Account.pubkey_hash random_implicit_account
-  in
-  let only_success = not with_rejections in
-  let manager_tz_test ~contract_arg ~expected ~output_msg =
-    let command =
-      [
-        "--wait";
-        "none";
-        "transfer";
-        "0";
-        "from";
-        ledger_key;
-        "to";
-        manager_tz_kt1_account;
-        "--entrypoint";
-        "do";
-        "--arg";
-        contract_arg;
-        "--burn-cap";
-        "1";
-        "--storage-limit";
-        "500";
-        "--verbose-signing";
-      ]
-    in
-    with_ledger_test_reject_and_accept
-      state
-      ~only_success
-      ~messages:
-        MFmt.
-          [
-            (fun ppf () ->
-              wf ppf "Managing account of manager.tz contract `%s`" ledger_pkh);
-            show_command_message command;
-            (fun ppf () ->
-              wf
-                ppf
-                "Note that X is a placeholder for some value that will vary \
-                 between runs");
-            (fun ppf () -> ledger_should_display ppf expected);
-          ]
-      (fun ~user_answer ->
-        let* res =
-          client_async_cmd
-            state
-            ~client
-            ~f:(fun _ proc ->
-              find_and_print_signature_hash
-                ~display_expectation:Poly.(protocol_kind = `Babylon)
-                state
-                proc)
-            command
-        in
-        expect_from_output
-          ~message:output_msg
-          res
-          ~expectation:
-            (match user_answer with
-            | `Reject -> `Ledger_reject_or_timeout
-            | `Accept -> `Success))
-  in
-  let set_delegation () =
-    manager_tz_test
-      ~contract_arg:
-        (sprintf
-           "{ DROP ; NIL operation ; PUSH key_hash \"%s\" ; SOME ; \
-            SET_DELEGATE ; CONS }"
-           delegate_pkh)
-      ~expected:
-        MFmt.
-          [
-            ("Confirm Delegation", const string "");
-            ("Fee", const string "0.00XXX");
-            ("Source", const string contract_address);
-            ("Delegate", const string delegate_pkh);
-            ( "Delegate Name",
-              const string "Custom Delegate: please verify the addresss" );
-            ("Storage Limit", const int 500);
-          ]
-      ~output_msg:"delegation"
-  in
-  let remove_delegation () =
-    manager_tz_test
-      ~contract_arg:
-        "{ DROP ; NIL operation ; NONE key_hash ; SET_DELEGATE ; CONS }"
-      ~expected:
-        MFmt.
-          [
-            ("Withdraw Delegation", const string "");
-            ("Fee", const string "0.00XXX");
-            ("Source", const string contract_address);
-            ("Delegate", const string "None");
-            ( "Delegate Name",
-              const string "Custom Delegate: please verify the address" );
-            ("Storage Limit", const int 500);
-          ]
-      ~output_msg:"delegate-removal"
-  in
-  let manager_tz_to_implicit () =
-    manager_tz_test
-      ~contract_arg:
-        (sprintf
-           "{ DROP ; NIL operation ; PUSH key_hash \"%s\" ; IMPLICIT_ACCOUNT ; \
-            PUSH mutez %d ; UNIT ; TRANSFER_TOKENS ; CONS }"
-           random_acc_pkh
-           10000000)
-      ~expected:
-        MFmt.
-          [
-            ("Confirm Transaction", const string "");
-            ("Amount", const int 10);
-            ("Fee", const string "0.00XXX");
-            ("Source", const string contract_address);
-            ("Destination", const string random_acc_pkh);
-            ("Storage Limit", const int 500);
-          ]
-      ~output_msg:"transfer-from-manager-tz-to-implicit"
-  in
-  let manager_tz_to_originated_large () =
-    manager_tz_test
-      ~contract_arg:
-        (sprintf
-           "{ DROP ; NIL operation ; PUSH address \"%s\" ; CONTRACT unit ; \
-            ASSERT_SOME ; PUSH mutez %d ; UNIT ; TRANSFER_TOKENS ; CONS }"
-           random_contract_pkh
-           (300 * 1000000))
-      ~expected:
-        MFmt.
-          [
-            ("Confirm Transaction", const string "");
-            ("Amount", const int 300);
-            ("Fee", const string "0.00XXX");
-            ("Source", const string contract_address);
-            ("Destination", const string random_contract_pkh);
-            ("Storage Limit", const int 500);
-          ]
-      ~output_msg:"transfer-from-manager-tz-to-originated"
-  in
-  let manager_tz_to_originated_small () =
-    manager_tz_test
-      ~contract_arg:
-        (sprintf
-           "{ DROP ; NIL operation ; PUSH address \"%s\" ; CONTRACT unit ; \
-            ASSERT_SOME ; PUSH mutez %d ; UNIT ; TRANSFER_TOKENS ; CONS }"
-           random_contract_pkh
-           3)
-      ~expected:
-        MFmt.
-          [
-            ("Confirm Transaction", const string "");
-            ("Amount", const string "0.000003");
-            ("Fee", const string "0.00XXX");
-            ("Source", const string contract_address);
-            ("Destination", const string random_contract_pkh);
-            ("Storage Limit", const int 500);
-          ]
-      ~output_msg:"transfer-from-manager-tz-to-originated"
-  in
-  let* () = return () in
-  let* _ = set_delegation () in
-  let* () = ksprintf bake "setting delegate of %s" contract_address in
-  let* _ = remove_delegation () in
-  let* () = ksprintf bake "removing delegate of %s" contract_address in
-  let* _ = manager_tz_to_implicit () in
-  let* () =
-    ksprintf bake "transferring from %s to %s" contract_address random_acc_pkh
-  in
-  let* _ = manager_tz_to_originated_large () in
-  let* () =
-    ksprintf
-      bake
-      "transfering from %s to %s"
-      contract_address
-      random_contract_pkh
-  in
-  let* _ = manager_tz_to_originated_small () in
-  ksprintf bake "transfering from %s to %s" contract_address random_contract_pkh
-
-let delegation_tests state ~client ~src ~with_rejections ~protocol_kind
-    ~ledger_account ~delegate ~delegate_pkh ~bake () =
-  let ledger_pkh = Tezos_protocol.Account.pubkey_hash ledger_account in
-  let only_success = not with_rejections in
-  let self_delegation () =
-    (* Which is equivalent to registration as delegate. *)
-    let command =
-      [
-        "--wait";
-        "none";
-        "set";
-        "delegate";
-        "for";
-        src;
-        "to";
-        src;
-        "--verbose-signing";
-      ]
-    in
-    let* _ =
-      with_ledger_test_reject_and_accept
-        state
-        ~only_success
-        ~messages:
-          MFmt.
-            [
-              (fun ppf () -> wf ppf "Self-delegating account `%s`" ledger_pkh);
-              show_command_message command;
-              (fun ppf () ->
-                wf
-                  ppf
-                  "Note that X is a placeholder for some value that will vary \
-                   between runs");
-              (fun ppf () ->
-                ledger_should_display
-                  ~title:"Confirm Delegation"
-                  ppf
-                  [
-                    ("Fee", const string "0.00XXX");
-                    ("Source", const string ledger_pkh);
-                    ("Delegate", const string ledger_pkh);
-                    ("Delegate Name", const string "Obsidian");
-                    ("Storage", const int 0);
-                  ]);
-            ]
-        (fun ~user_answer ->
-          let* res =
-            client_async_cmd
-              state
-              ~client
-              ~f:(fun _ proc ->
-                find_and_print_signature_hash
-                  ~display_expectation:Poly.(protocol_kind = `Babylon)
-                  state
-                  proc)
-              command
-          in
-          expect_from_output
-            ~message:"self-delegation"
-            res
-            ~expectation:
-              (match user_answer with
-              | `Reject -> `Ledger_reject_or_timeout
-              | `Accept -> `Success))
-    in
-    ksprintf bake "setting self-delegate of %s" src
-    (* Self-delegate deletion is forbidden for both Athens and Babylon *)
-  in
-  let tz_account_delegation () =
-    let command =
-      [
-        "--wait";
-        "none";
-        "set";
-        "delegate";
-        "for";
-        src;
-        "to";
-        delegate;
-        "--verbose-signing";
-      ]
-    in
-    let* _ =
-      with_ledger_test_reject_and_accept
-        state
-        ~only_success
-        ~messages:
-          MFmt.
-            [
-              (fun ppf () ->
-                wf ppf "Delegating account `%s` to `%s`" ledger_pkh delegate);
-              show_command_message command;
-              (fun ppf () ->
-                wf
-                  ppf
-                  "Note that X is a placeholder for some value that will vary \
-                   between runs");
-              (fun ppf () ->
-                ledger_should_display
-                  ~title:"Confirm Delegation"
-                  ppf
-                  [
-                    ("Fee", const string "0.00XXX");
-                    ("Source", const string ledger_pkh);
-                    ("Delegate", const string delegate_pkh);
-                    ( "Delegate Name",
-                      const string "Custom Delegate: please verify the address"
-                    );
-                    ("Storage Limit", const int 0);
-                  ]);
-            ]
-        (fun ~user_answer ->
-          let* res =
-            client_async_cmd
-              state
-              ~client
-              ~f:(fun _ proc ->
-                find_and_print_signature_hash
-                  ~display_expectation:Poly.(protocol_kind = `Babylon)
-                  state
-                  proc)
-              command
-          in
-          expect_from_output
-            ~message:"tz123-delegation"
-            res
-            ~expectation:
-              (match user_answer with
-              | `Reject -> `Ledger_reject_or_timeout
-              | `Accept -> `Success))
-    in
-    ksprintf bake "setting delegate of %s" src
-    (* Self-delegate deletion is forbidden for both Athens and Babylon *)
-  in
-  match protocol_kind with
-  | `Athens -> self_delegation ()
-  | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada | `Hangzhou
-  | `Ithaca | `Jakarta | `Alpha ->
-      let* () = tz_account_delegation () in
-      self_delegation ()
-
-let transaction_tests state ~client ~src ~with_rejections ~protocol_kind
-    ~pair_string_nat_kt1_account ~ledger_account ~unit_kt1_account ~bake () =
-  let ledger_pkh = Tezos_protocol.Account.pubkey_hash ledger_account in
-  let only_success = not with_rejections in
-  let test_transaction ?storage_limit ?arguments ~name ~dst_name ~dst_pkh
-      ?entrypoint ?(amount = 15) ?fee () =
-    let command =
-      let opt = Option.value_map ~default:[] in
-      let storage =
-        match storage_limit with
-        | None -> []
-        | Some limit -> ["--storage-limit"; sprintf "%d" limit]
-      in
-      [
-        "--wait";
-        "none";
-        "transfer";
-        sprintf "%i" amount;
-        "from";
-        src;
-        "to";
-        dst_name;
-      ]
-      @ Option.value_map ~default:[] arguments ~f:(fun a -> ["--arg"; a])
-      @ Option.value_map ~default:[] fee ~f:(fun f -> ["--fee"; sprintf "%d" f])
-      @ storage @ ["--fee-cap"; "10"]
-      @ opt entrypoint ~f:(fun e -> ["--entrypoint"; e])
-      @ ["--burn-cap"; "100"; "--verbose-signing"]
-    in
-    let* _ =
-      with_ledger_test_reject_and_accept
-        state
-        ~only_success
-        ~messages:
-          MFmt.
-            [
-              (fun ppf () -> wf ppf "%s with account `%s`" name ledger_pkh);
-              show_command_message command;
-              (fun ppf () ->
-                wf
-                  ppf
-                  "Note that X is a placeholder for some value that will vary \
-                   between runs");
-              (fun ppf () ->
-                match arguments with
-                | None ->
-                    ledger_should_display
-                      ppf
-                      [
-                        ("Amount", const int amount);
-                        ( "Fee",
-                          const string
-                          @@ Option.value_map
-                               ~default:"0.00XXX"
-                               fee
-                               ~f:(sprintf "%d") );
-                        ("Source", const string ledger_pkh);
-                        ("Destination", const string dst_pkh);
-                        ( "Storage Limit",
-                          const int
-                          @@ match storage_limit with None -> 0 | Some s -> s );
-                      ]
-                | _ (* some arguments *) -> please_check_the_hash ppf ());
-            ]
-        (fun ~user_answer ->
-          let* res =
-            client_async_cmd
-              state
-              ~client
-              ~f:(fun _ proc ->
-                find_and_print_signature_hash
-                  ~display_expectation:
-                    Poly.(protocol_kind = `Babylon || arguments <> None)
-                  state
-                  proc)
-              command
-          in
-          expect_from_output
-            ~message:name
-            res
-            ~expectation:
-              (match user_answer with
-              | `Reject -> `Ledger_reject_or_timeout
-              | `Accept -> `Success))
-    in
-    ksprintf bake "%s with %s" name src
-  in
-  let* () =
-    test_transaction
-      ~name:"Self-transaction"
-      ~dst_pkh:ledger_pkh
-      ~dst_name:src
-      ()
-  in
-  let module Acc = Tezos_protocol.Account in
-  let random_account = Acc.of_name "random-account-for-transaction-test" in
-  let* () =
-    test_transaction
-      ~name:"transaction-to-random-tz1"
-      ~dst_pkh:(Acc.pubkey_hash random_account)
-      ~dst_name:(Acc.pubkey_hash random_account)
-      ~storage_limit:277
-      (* First time: there is a reveal *) ()
-  in
-  let* () =
-    test_transaction
-      ~name:"transaction-to-random-tz1-again"
-      ~dst_pkh:(Acc.pubkey_hash random_account)
-      ~dst_name:(Acc.pubkey_hash random_account)
-      ~storage_limit:0
-      (* no moa reveal *) ()
-  in
-  let* () =
-    test_transaction
-      ~name:"transaction-to-random-tz1-fee-no-storage-limit"
-      ~dst_pkh:(Acc.pubkey_hash random_account)
-      ~dst_name:(Acc.pubkey_hash random_account)
-      ~fee:2
-      ()
-  in
-  let* () =
-    test_transaction
-      ~name:"transaction-to-random-tz1-fee-storage-limit"
-      ~dst_pkh:(Acc.pubkey_hash random_account)
-      ~dst_name:(Acc.pubkey_hash random_account)
-      ~fee:2
-      ~storage_limit:500
-      ()
-  in
-  let* () =
-    test_transaction
-      ~name:"parameterless-transaction-to-kt1"
-      ~dst_pkh:"KT1XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
-      ~dst_name:unit_kt1_account
-      ()
-  in
-  test_transaction
-    ~name:"parameterfull-transaction-to-kt1"
-    ~dst_pkh:"KT1XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
-    ~arguments:"Pair \"hello from the ledger\" 51"
-    ~dst_name:pair_string_nat_kt1_account
-    ()
-
-let prepare_origination_of_id_script ?(spendable = false) ?(delegatable = false)
-    ?delegate ?(push_drops = 0) ?(amount = "2") state ~client:_ ~name ~from
-    ~protocol_kind ~parameter ~init_storage =
-  let id_script parameter =
-    Fmt.str
-      "parameter %s;\n\
-       storage %s;\n\
-       code\n\
-      \  {\n\
-      \    %s\n\
-      \    { CAR; NIL operation; PAIR }\n\
-      \  };\n"
-      parameter
-      parameter
-      (match push_drops with
-      | 0 -> "# No push-drops"
-      | n ->
-          Fmt.str
-            "# %d push-drop%s\n    %s"
-            n
-            (if n > 1 then "s" else "")
-            (List.init push_drops ~f:(fun ith ->
-                 Fmt.str
-                   "{ PUSH string %S ; DROP } ;"
-                   (Fmt.str
-                      "push-dropping %d adds stupid bytes to the contract"
-                      ith))
-            |> String.concat ~sep:"\n    "))
-  in
-  let tmp = Caml.Filename.temp_file "little-id-script" ".tz" in
-  let* () = System.write_file state tmp ~content:(id_script parameter) in
-  Dbg.e EF.(wf "id_script %s: %s" parameter tmp) ;
-  let origination =
-    let opt = Option.value_map ~default:[] in
-    ["--wait"; "none"; "originate"; "contract"; name]
-    @ (match protocol_kind with
-      | `Athens -> ["for"; from]
-      | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada | `Hangzhou
-      | `Ithaca | `Jakarta | `Alpha ->
-          [])
-    @ [
-        "transferring";
-        amount;
-        "from";
-        from;
-        "running";
-        tmp;
-        "--init";
-        init_storage;
-        "--force";
-        "--burn-cap";
-        "300000000000";
-        (* ; "--fee-cap" ; "20000000000000" *)
-        "--gas-limit";
-        "1000000000000000";
-        "--storage-limit";
-        "20000000000000";
-        "--verbose-signing";
-      ]
-    @ opt delegate ~f:(fun s -> (* Baby & Aths *) ["--delegate"; s])
-    @ (if delegatable then [(* Aths *) "--delegatable"] else [])
-    @ if spendable then [(* Aths *) "--spendable"] else []
-  in
-  return origination
-
-let originate_id_script ?push_drops state ~client ~name ~from ~bake
-    ~protocol_kind ~parameter ~init_storage =
-  let* origination =
-    prepare_origination_of_id_script
-      state
-      ~client
-      ~name
-      ~from
-      ~protocol_kind
-      ?push_drops
-      ~parameter
-      ~init_storage
-  in
-  let* _ = Tezos_client.successful_client_cmd state ~client origination in
-  Fmt.kstr bake "baking `%s` in" name
-
-let pp_warning_ledger_takes_a_while ~adjective =
-  let open MFmt in
-  fun ppf () ->
-    cut ppf () ;
-    let prompt = "WARNING: " in
-    let warning1 = "The ledger will take a few seconds to show" in
-    let warning2 = str "the hash for such a %s operation." adjective in
-    let wl = String.length prompt + String.length warning1 in
-    tag "shout" ppf (fun ppf -> string ppf ("/" ^ String.make wl '=' ^ "\\")) ;
-    cut ppf () ;
-    tag "shout" ppf (fun ppf -> pf ppf "|%s" prompt) ;
-    string ppf warning1 ;
-    tag "shout" ppf (fun ppf -> string ppf "|") ;
-    cut ppf () ;
-    tag "shout" ppf (fun ppf -> pf ppf "|") ;
-    string ppf String.(make (length prompt) ' ') ;
-    string ppf warning2 ;
-    string ppf String.(make (length warning1 - length warning2) ' ') ;
-    tag "shout" ppf (fun ppf -> string ppf "|") ;
-    cut ppf () ;
-    tag "shout" ppf (fun ppf -> string ppf ("\\" ^ String.make wl '=' ^ "/"))
-
-let basic_contract_operations_tests state ~client ~src ~with_rejections
-    ~protocol_kind ~ledger_account ~bake ~delegate () =
-  let ledger_pkh = Tezos_protocol.Account.pubkey_hash ledger_account in
-  let only_success = not with_rejections in
-  let test_origination ?delegate ?delegatable ?spendable ?push_drops ~name
-      ~amount ~parameter ~init_storage () =
-    let* origination =
-      prepare_origination_of_id_script
-        ~amount
-        ?push_drops
-        state
-        ~client
-        ~name
-        ~from:src
-        ?delegate
-        ?delegatable
-        ?spendable
-        ~protocol_kind
-        ~parameter
-        ~init_storage
-    in
-    let* _ =
-      with_ledger_test_reject_and_accept
-        state
-        ~only_success
-        ~messages:
-          MFmt.
-            [
-              (fun ppf () ->
-                wf ppf "Origination: %s (ledger: %s)" name ledger_pkh);
-              show_command_message origination;
-              please_check_the_hash;
-              (if Poly.(push_drops <> None) then
-               pp_warning_ledger_takes_a_while ~adjective:"huge"
-              else const string "");
-            ]
-        (fun ~user_answer ->
-          let* res =
-            client_async_cmd
-              state
-              ~client
-              ~f:(fun _ proc ->
-                find_and_print_signature_hash
-                  ~display_expectation:true
-                  state
-                  proc)
-              origination
-          in
-          expect_from_output
-            ~message:name
-            res
-            ~expectation:
-              (match user_answer with
-              | `Reject -> `Ledger_reject_or_timeout
-              | `Accept -> `Success))
-    in
-    ksprintf bake "%s with %s" name src
-  in
-  let* () =
-    test_origination
-      ~name:"ID-unit"
-      ~amount:"0"
-      ~parameter:"unit"
-      ~init_storage:"Unit"
-      ()
-  in
-  let* () =
-    test_origination
-      ~name:"ID-string"
-      ~amount:"10"
-      ~parameter:"string"
-      ~init_storage:"\"some string\""
-      ()
-  in
-  let* () =
-    test_origination
-      ~name:"ID-string-nat-mutez"
-      ~amount:"10"
-      ~parameter:"(pair string (pair nat mutez))"
-      ~init_storage:"Pair \"hello\" (Pair 12 1)"
-      ()
-  in
-  let* () =
-    test_origination
-      ~name:"ID-address+delegate"
-      ~amount:"1"
-      ~parameter:"address"
-      ~delegate
-      ~init_storage:"\"tz1YPSCGWXwBdTncK2aCctSZAXWvGsGwVJqU\""
-      ()
-  in
-  let* () =
-    match protocol_kind with
-    | `Athens ->
-        test_origination
-          ~name:"ID-string+delegatable"
-          ~amount:"0"
-          ~parameter:"string"
-          ~delegate
-          ~init_storage:"\"delegatable contract\""
-          ~delegatable:true
-          ()
-    | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada | `Hangzhou
-    | `Ithaca | `Jakarta | `Alpha ->
-        return ()
-  in
-  let push_drops =
-    (* Found by dichotomic trial-and-error :)
-       240 works, 250 fails at 16870 bytes, … *)
-    242
-  in
-  test_origination
-    ~push_drops
-    ~name:"giant-contract"
-    ~amount:"10"
-    ~parameter:"(pair string nat)"
-    ~init_storage:"Pair \"the answer is: \" 42"
-    ()
-
-module Wallet_scenario = struct
-  type root =
-    [ `All
-    | `Voting
-    | `Batch_transactions
-    | `Manager
-    | `Delegation
-    | `Transactions
-    | `Contracts
-    | `None ]
-
-  type t = [root | `Without_rejections of root]
-
-  let with_rejections : t -> bool = function
-    | `Without_rejections _ -> false
-    | _ -> true
-
-  let enum_assoc : (string * root) list =
-    [
-      ("everything", `All);
-      ("voting", `Voting);
-      ("none", `None);
-      ("delegation", `Delegation);
-      ("transactions", `Transactions);
-      ("contracts", `Contracts);
-      ("manager", `Manager);
-      ("batch-transactions", `Batch_transactions);
-    ]
-
-  let root (ws : t) =
-    match ws with `Without_rejections r -> r | #root as r -> r
-
-  let run_if v t ~yes ~no =
-    let with_rejections = with_rejections t in
-    match root t with
-    | `All -> yes ~with_rejections
-    | other when Poly.(other = v) -> yes ~with_rejections
-    | _other ->
-        no
-          (List.find_map_exn enum_assoc ~f:(function
-              | k, this when Poly.(v = this) -> Some k
-              | _ -> None))
-
-  let if_voting t = run_if `Voting t
-
-  let if_batch_transactions t = run_if `Batch_transactions t
-
-  let if_delegation t = run_if `Delegation t
-
-  let if_manager t = run_if `Manager t
-
-  let if_transactions t = run_if `Transactions t
-
-  let if_contracts t = run_if `Contracts t
-
-  let cli_term () =
-    let make no_rejections v =
-      if no_rejections then `Without_rejections v else (v :> t)
-    in
-    let open Cmdliner in
-    let open Term in
-    const make
-    $ Arg.(
-        value
-          (flag (info ["no-rejections"] ~doc:"Do not test ledger rejections.")))
-    $ Arg.(
-        value
-          (opt
-             (enum ([("all", `All)] @ enum_assoc))
-             `All
-             (info
-                ["only-test"]
-                ~doc:
-                  (Fmt.str
-                     "Limit to a family of tests (one of: %s)."
-                     (List.map enum_assoc ~f:(fun (n, _) -> sprintf "`%s`" n)
-                     |> String.concat ~sep:", ")))))
-end
-
-let run state ~pp_error ~protocol ~protocol_kind ~node_exec ~client_exec
-    ~admin_exec ~wallet_scenario ~size ~base_port ~uri () =
-  let* () = Helpers.clear_root state in
-  let* () =
-    Helpers.System_dependencies.precheck
-      state
-      `Or_fail
-      ~executables:[node_exec; client_exec; admin_exec]
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Ready to start"; af "Root path deleted."]
-  in
-  let ledger_client = Tezos_client.no_node_client ~exec:client_exec in
-  let* _ledger_account =
-    Tezos_client.Ledger.show_ledger state ~client:ledger_client ~uri
-  in
-  let protocol, baker_0_account, _baker_0_balance =
-    let open Tezos_protocol in
-    let d = protocol in
-    let baker = List.nth_exn d.bootstrap_accounts 0 in
-    ( {
-        d with
-        kind = protocol_kind;
-        time_between_blocks = [1; 0];
-        minimal_block_delay = 1;
-        bootstrap_accounts =
-          List.map d.bootstrap_accounts ~f:(fun (n, v) ->
-              if Poly.(fst baker = n) then (n, v) else (n, 1_000L));
-      },
-      fst baker,
-      snd baker )
-  in
-  let* nodes, protocol =
-    Test_scenario.network_with_protocol
-      ~protocol
-      ~size
-      ~base_port
-      state
-      ~node_exec
-      ~client_exec
-  in
-  let client n =
-    Tezos_client.of_node ~exec:client_exec (List.nth_exn nodes n)
-  in
-  let client_0 = client 0 in
-  let baker_0 =
-    Tezos_client.Keyed.make
-      client_0
-      ~key_name:"baker-0"
-      ~secret_key:(Tezos_protocol.Account.private_key baker_0_account)
-  in
-  let* _ = Tezos_client.Keyed.initialize state baker_0 in
-  let make_admin = Tezos_admin_client.of_client ~exec:admin_exec in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes
-      @ [secret_keys state ~protocol; Log_recorder.Operations.show_all state]
-      @ arbitrary_commands_for_each_and_all_clients
-          state
-          ~make_admin
-          ~clients:(List.map nodes ~f:(Tezos_client.of_node ~exec:client_exec))) ;
-  let first_bakes = 3 in
-  let* () =
-    Loop.n_times first_bakes (fun nth ->
-        ksprintf (Tezos_client.Keyed.bake state baker_0) "initial-bake %d" nth)
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "About to really start playing"]
-  in
-  let signer =
-    Tezos_client.Keyed.make (client 0) ~key_name:"ledgered" ~secret_key:uri
-  in
-  let* ledger_account =
-    Tezos_client.Ledger.show_ledger state ~client:client_0 ~uri
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:client_0
-      [
-        "--wait";
-        "none";
-        "transfer";
-        "20000";
-        "from";
-        baker_0.Tezos_client.Keyed.key_name;
-        "to" (*  *);
-        Tezos_protocol.Account.pubkey_hash ledger_account;
-        "--burn-cap";
-        "100";
-      ]
-  in
-  let bake msg = Tezos_client.Keyed.bake state baker_0 msg in
-  let* () = bake "After transferring tez to the ledger account" in
-  let* () =
-    with_ledger_test_reject_and_accept
-      ~only_success:(Wallet_scenario.with_rejections wallet_scenario |> not)
-      state
-      ~messages:
-        MFmt.
-          [
-            (fun ppf () ->
-              wf ppf "Importing %S in client `%s`." uri client_0.Tezos_client.id);
-            (fun ppf () ->
-              wf
-                ppf
-                "The ledger should be prompting for acknowledgment to provide \
-                 the public key of `%s`."
-                (Tezos_protocol.Account.pubkey_hash ledger_account));
-          ]
-      (fun ~user_answer ->
-        let* _, proc =
-          Tezos_client.client_cmd
-            state
-            ~client:client_0
-            [
-              "import";
-              "secret";
-              "key";
-              signer.key_name;
-              signer.secret_key;
-              "--force";
-            ]
-        in
-        expect_from_output
-          ~message:"importing key"
-          proc
-          ~expectation:
-            (match user_answer with
-            | `Accept -> `Success
-            | `Reject -> `Ledger_reject_or_timeout))
-  in
-  let skipping s = Console.say state EF.(haf "Skipping %s tests" s) in
-  let voting_test ~with_rejections =
-    let tested_proposal =
-      "Pt24m4xiPbLDhVgVfABUjirbmda3yohdN82Sp9FeuAXJ4eV9otd"
-    in
-    voting_tests
-      state
-      ~client
-      ~ledger_account
-      ~src:signer.key_name
-      ()
-      ~with_rejections
-      ~protocol_kind
-      ~tested_proposal
-      ~go_to_next_period:(fun () ->
-        let* _ =
-          Tezos_client.successful_client_cmd
-            state
-            ~client:client_0
-            [
-              "--wait";
-              "none";
-              "submit";
-              "proposals";
-              "for";
-              baker_0.Tezos_client.Keyed.key_name;
-              tested_proposal;
-              "--force";
-            ]
-        in
-        let blocks = protocol.Tezos_protocol.blocks_per_voting_period in
-        let* () =
-          Loop.n_times blocks (fun nth ->
-              ksprintf
-                (Tezos_client.Keyed.bake state baker_0)
-                "going to testing-vote period %d/%d"
-                (nth + 1)
-                blocks)
-        in
-        return ())
-  in
-  let batch_test ~with_rejections =
-    let n = 50 in
-    let forge_batch_transactions state ~client ~src ~dest:_ ~n ?(fee = 0.00126)
-        () =
-      let* branch = get_head_block_hash state ~client () in
-      let json =
-        `O
-          [
-            ("branch", `String branch);
-            ( "contents",
-              `A
-                (List.map (List.range 0 n) ~f:(fun i ->
-                     `O
-                       [
-                         ("kind", `String "transaction");
-                         ("source", `String src);
-                         ( "destination",
-                           `String "tz2KZPgf2rshxNUBXFcTaCemik1LH1v9qz3F" );
-                         ("amount", `String (Int.to_string 100));
-                         ( "fee",
-                           `String
-                             (Int.to_string (Float.to_int (fee *. 1000000.))) );
-                         ("counter", `String (Int.to_string i));
-                         ("gas_limit", `String (Int.to_string 127));
-                         ("storage_limit", `String (Int.to_string 277));
-                       ])) );
-          ]
-      in
-      let* json =
-        Tezos_client.rpc
-          state
-          ~client
-          ~path:"/chains/main/blocks/head/helpers/forge/operations"
-          (`Post (Ezjsonm.to_string json))
-      in
-      match json with
-      | `String operation_bytes ->
-          let magic_byte = "03" in
-          return (magic_byte ^ operation_bytes)
-      | _ -> failf "Failed to forge operation or parse result"
-    in
-    let* batch_transaction_bytes =
-      forge_batch_transactions
-        state
-        ~client:(client 0)
-        ~src:(Tezos_protocol.Account.pubkey_hash ledger_account)
-        ~dest:"tz2KZPgf2rshxNUBXFcTaCemik1LH1v9qz3F"
-        ~n
-        ()
-    in
-    let bytes_hash =
-      Tezos_crypto.(
-        `Hex batch_transaction_bytes |> Tezos_stdlib.Hex.to_bytes_exn
-        |> (fun x -> [x])
-        |> Blake2B.hash_bytes |> Blake2B.to_string |> Base58.raw_encode)
-    in
-    let sign state ~client ~bytes =
-      Tezos_client.client_cmd
-        state
-        ~client:client.Tezos_client.Keyed.client
-        [
-          "sign";
-          "bytes";
-          "0x" ^ bytes;
-          "for";
-          client.Tezos_client.Keyed.key_name;
-        ]
-    in
-    with_ledger_test_reject_and_accept
-      state
-      ~only_success:(not with_rejections)
-      ~messages:
-        MFmt.
-          [
-            (fun ppf () -> wf ppf "Signing batch of %d transactions" n);
-            (fun ppf () ->
-              wf ppf "Ledger should display “Sign Hash” → `%s`" bytes_hash);
-            pp_warning_ledger_takes_a_while ~adjective:"big";
-          ]
-      (fun ~user_answer ->
-        let* _, proc =
-          sign state ~client:signer ~bytes:batch_transaction_bytes
-        in
-        expect_from_output
-          ~message:"Signing batch operation"
-          proc
-          ~expectation:
-            (match user_answer with
-            | `Accept -> `Success
-            | `Reject -> `Ledger_reject_or_timeout))
-  in
-  let delegation_tests ~with_rejections =
-    delegation_tests
-      state
-      ~client:client_0
-      ~ledger_account
-      ~delegate:baker_0.Tezos_client.Keyed.key_name
-      ~delegate_pkh:(Tezos_protocol.Account.pubkey_hash baker_0_account)
-      ~src:signer.key_name
-      ()
-      ~bake
-      ~with_rejections
-      ~protocol_kind
-  in
-  let unit_kt1_account = "unit-kt1-of-the-baker" in
-  let* () =
-    originate_id_script
-      state
-      ~client:client_0
-      ~name:unit_kt1_account
-      ~from:baker_0.Tezos_client.Keyed.key_name
-      ~bake
-      ~protocol_kind
-      ~parameter:"unit"
-      ~init_storage:"Unit"
-  in
-  let* _, proc_result =
-    Tezos_client.client_cmd
-      state
-      ~client:client_0
-      ["show"; "known"; "contract"; unit_kt1_account]
-  in
-  let unit_kt1_contract_address = proc_result#out |> String.concat ~sep:"" in
-  let pair_string_nat_kt1_account = "pair-string-nat-kt1-of-the-baker" in
-  let* () =
-    originate_id_script
-      state
-      ~client:client_0
-      ~name:pair_string_nat_kt1_account
-      ~push_drops:10
-      ~from:baker_0.Tezos_client.Keyed.key_name
-      ~bake
-      ~protocol_kind
-      ~parameter:"(pair string nat)"
-      ~init_storage:"Pair \"the answer is: \" 42"
-  in
-  let transactions_test ~with_rejections =
-    transaction_tests
-      state
-      ~client:client_0
-      ~ledger_account
-      ~unit_kt1_account
-      ~pair_string_nat_kt1_account
-      ~src:signer.key_name
-      ()
-      ~bake
-      ~with_rejections
-      ~protocol_kind
-  in
-  let manager_tz_delegation_tests ~with_rejections =
-    manager_tz_delegation_tests
-      state
-      ~client:client_0
-      ~ledger_key:signer.key_name
-      ~ledger_account
-      ~delegate_pkh:(Tezos_protocol.Account.pubkey_hash baker_0_account)
-      ()
-      ~bake
-      ~random_contract_pkh:unit_kt1_contract_address
-      ~with_rejections
-      ~protocol_kind
-  in
-  let contracts_test ~with_rejections =
-    basic_contract_operations_tests
-      state
-      ~client:client_0
-      ~ledger_account
-      ~delegate:baker_0.Tezos_client.Keyed.key_name
-      ~src:signer.key_name
-      ()
-      ~bake
-      ~with_rejections
-      ~protocol_kind
-  in
-  let bake_command =
-    Console.Prompt.unit_and_loop
-      ~description:"Bake a block with the default baker."
-      ["bake"]
-      (fun _sexps ->
-        Asynchronous_result.transform_error
-          ~f:(fun e ->
-            Fmt.kstr (fun s -> `Command_line s) "run-test-error: %a" pp_error e)
-          (bake "Interactive"))
-  in
-  let run_test_command =
-    Console.Prompt.unit_and_loop
-      ~description:
-        Fmt.(
-          str
-            "Run a test (%s)."
-            (List.map Wallet_scenario.enum_assoc ~f:fst
-            |> String.concat ~sep:"|"))
-      ["rt"; "run-test"]
-      (fun sexps ->
-        Asynchronous_result.transform_error
-          ~f:(fun e ->
-            Fmt.kstr (fun s -> `Command_line s) "run-test-error: %a" pp_error e)
-          (match sexps with
-          | [Atom a] -> (
-              let run f = f ~with_rejections:true in
-              match
-                List.Assoc.find ~equal:String.equal Wallet_scenario.enum_assoc a
-              with
-              | Some `None -> return ()
-              | Some `Delegation -> run delegation_tests
-              | Some `Manager -> run manager_tz_delegation_tests
-              | Some `All ->
-                  let* () = run delegation_tests in
-                  let* () = run manager_tz_delegation_tests in
-                  let* () = run batch_test in
-                  let* () = run transactions_test in
-                  let* () = run voting_test in
-                  run contracts_test
-              | Some `Batch_transactions -> run batch_test
-              | Some `Transactions -> run transactions_test
-              | Some `Voting -> run voting_test
-              | Some `Contracts -> run contracts_test
-              | None -> failf "Don't know this test: %S" a)
-          | _ -> failf "Cannot understand command line"))
-  in
-  Interactive_test.Pauser.add_commands state [run_test_command; bake_command] ;
-  let* () =
-    Wallet_scenario.if_voting wallet_scenario ~yes:voting_test ~no:skipping
-  in
-  let* () =
-    Wallet_scenario.if_batch_transactions
-      wallet_scenario
-      ~yes:batch_test
-      ~no:skipping
-  in
-  let* () =
-    Wallet_scenario.if_transactions
-      wallet_scenario
-      ~yes:transactions_test
-      ~no:skipping
-  in
-  let* () =
-    Wallet_scenario.if_contracts
-      wallet_scenario
-      ~yes:contracts_test
-      ~no:skipping
-  in
-  let* () =
-    Wallet_scenario.if_delegation
-      wallet_scenario
-      ~yes:delegation_tests
-      ~no:skipping
-  in
-  let* () =
-    Wallet_scenario.if_manager
-      wallet_scenario
-      ~yes:manager_tz_delegation_tests
-      ~no:skipping
-  in
-  Interactive_test.Pauser.generic state EF.[af "Tests done."]
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"ledger-wallet"
-      ()
-  in
-  let docs = Manpage_builder.section_test_scenario base_state in
-  let term =
-    const
-      (fun
-        uri
-        node_exec
-        client_exec
-        admin_exec
-        size
-        (`Base_port base_port)
-        protocol
-        wallet_scenario
-        state
-      ->
-        Test_command_line.Run_command.or_hard_fail
-          state
-          ~pp_error
-          (Interactive_test.Pauser.run_test
-             ~pp_error
-             state
-             (run
-                state
-                ~protocol_kind:protocol.kind
-                ~node_exec
-                ~size
-                ~admin_exec
-                ~base_port
-                ~pp_error
-                ~wallet_scenario
-                ~protocol
-                ~client_exec
-                ~uri)))
-    $ Arg.(
-        required
-          (pos
-             0
-             (some string)
-             None
-             (info [] ~docv:"LEDGER-URI" ~docs ~doc:"ledger:// URI")))
-    $ Tezos_executable.cli_term base_state `Node "tezos"
-    $ Tezos_executable.cli_term base_state `Client "tezos"
-    $ Tezos_executable.cli_term base_state `Admin "tezos"
-    $ Arg.(value (opt int 2 (info ["size"; "S"] ~doc:"Size of the Network")))
-    $ Arg.(
-        const (fun p -> `Base_port p)
-        $ value
-            (opt
-               int
-               32_000
-               (info ["base-port"; "P"] ~doc:"Base port number to build upon")))
-    $ Tezos_protocol.cli_term base_state
-    $ Wallet_scenario.cli_term ()
-    $ Test_command_line.cli_state ~name:"ledger-wallet" ()
-  in
-  let info =
-    let doc = "Interactive test exercising the Ledger Wallet app features" in
-    Cmd.info ~doc "ledger-wallet"
-  in
-  Cmd.v info term
diff --git a/src/bin_sandbox/command_node_synchronization.ml b/src/bin_sandbox/command_node_synchronization.ml
deleted file mode 100644
index 3ce821e3f3e9825589682d38a9a23a78f3f7bb0b..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_node_synchronization.ml
+++ /dev/null
@@ -1,308 +0,0 @@
-open Flextesa
-open Internal_pervasives
-
-let default_attempts = 5
-
-let starting_level = 10
-
-let number_of_lonely_bakes = 100
-
-let run state ~node_exec ~client_exec ~primary_history_mode
-    ~secondary_history_mode ~should_synch () =
-  let* () = Helpers.clear_root state in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Ready to start"; af "Root path deleted."]
-  in
-  let block_interval = 1 in
-  let default_protocol = Tezos_protocol.default () in
-  let baker_list = default_protocol.bootstrap_accounts in
-  let protocol =
-    {
-      default_protocol with
-      timestamp_delay = Some (-3600);
-      expected_pow = 0;
-      time_between_blocks = [block_interval; 0];
-      minimal_block_delay = block_interval;
-    }
-  in
-  let primary_node =
-    Tezos_node.make
-      ~protocol
-      ~exec:node_exec
-      "primary_node"
-      ~history_mode:primary_history_mode
-      ~expected_connections:2
-      ~rpc_port:15001
-      ~p2p_port:15002
-      [15004]
-  in
-  let secondary_node =
-    Tezos_node.make
-      ~protocol
-      ~exec:node_exec
-      ~history_mode:secondary_history_mode
-      "secondary_node"
-      ~expected_connections:2
-      ~rpc_port:15003
-      ~p2p_port:15004
-      [15002]
-  in
-  let all_nodes = [primary_node; secondary_node] in
-  let* () = Helpers.dump_connections state all_nodes in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes:all_nodes
-      @ [secret_keys state ~protocol; Log_recorder.Operations.show_all state]) ;
-  let primary_client = Tezos_client.of_node ~exec:client_exec primary_node in
-  let pp_hm = function
-    | Some `Archive -> "archive"
-    | Some (`Full _) -> "full"
-    | Some (`Rolling _) -> "rolling"
-    | None -> "full"
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          af "Starting primary node in %s" (pp_hm primary_node.history_mode);
-          af "Starting secondary node in %s" (pp_hm secondary_node.history_mode);
-          af "Expecting nodes to synch after lonely baking run: %b" should_synch;
-        ]
-  in
-  let* _ =
-    Test_scenario.Network.(start_up state ~client_exec (make all_nodes))
-  in
-  let baker_account, _ = List.hd_exn baker_list in
-  let baker =
-    Tezos_client.Keyed.make
-      primary_client
-      ~key_name:(Tezos_protocol.Account.name baker_account)
-      ~secret_key:(Tezos_protocol.Account.private_key baker_account)
-  in
-  let* _ = Tezos_client.Keyed.initialize state baker in
-  let* () =
-    Loop.n_times (starting_level - 1) (fun i ->
-        Tezos_client.Keyed.bake
-          state
-          baker
-          (sprintf "bakery run: [%d/%d]" i starting_level))
-  in
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      all_nodes
-      (`Equal_to starting_level)
-  in
-  let* () = Helpers.kill_node state secondary_node in
-  let* () =
-    Loop.n_times number_of_lonely_bakes (fun i ->
-        Tezos_client.Keyed.bake
-          state
-          baker
-          (sprintf "lonely bakery run: [%d/%d]" i number_of_lonely_bakes))
-  in
-  let* json =
-    Tezos_client.rpc
-      state
-      ~client:primary_client
-      `Get
-      ~path:"/chains/main/checkpoint"
-  in
-  let* () =
-    match primary_history_mode with
-    | `Archive -> return ()
-    | `Rolling _ ->
-        let caboose_level = Jqo.(get_int @@ field ~k:"caboose" json) in
-        if not (caboose_level > starting_level) then
-          let msg =
-            sprintf
-              "Caboose level %d is lower or equal to starting level %d"
-              caboose_level
-              starting_level
-          in
-          fail (`Scenario_error msg)
-        else return ()
-    | `Full _ ->
-        let save_point_level = Jqo.(get_int @@ field ~k:"savepoint" json) in
-        if not (save_point_level > starting_level) then
-          let msg =
-            sprintf
-              "Save point level %d is lower or equal to starting level %d"
-              save_point_level
-              starting_level
-          in
-          fail (`Scenario_error msg)
-        else return ()
-  in
-  let* () = Helpers.restart_node ~client_exec state secondary_node in
-  let* are_synch =
-    Lwt.bind
-      (Test_scenario.Queries.wait_for_all_levels_to_be
-         state
-         ~attempts:default_attempts
-         ~seconds:8.
-         all_nodes
-         (`Equal_to (starting_level + number_of_lonely_bakes)))
-      (function
-        | {result = Ok _; _} when should_synch -> return true
-        | {result = Error (`Waiting_for (_, `Time_out)); _}
-          when not should_synch ->
-            return false
-        | _ ->
-            fail
-              (`Scenario_error
-                "Unexpected answer when waiting for nodes synchronization"))
-  in
-  let* () =
-    match (should_synch, are_synch) with
-    | false, true ->
-        fail (`Scenario_error "Nodes are not expected to be synchronized")
-    | true, false ->
-        fail (`Scenario_error "Nodes are expected to be synchronized")
-    | _ -> return ()
-  in
-  let identity_file = Tezos_node.identity_file state primary_node in
-  let* identity_contents = System.read_file state identity_file in
-  let identity_json = Ezjsonm.from_string identity_contents in
-  let primary_node_peer_id =
-    Ezjsonm.value_to_string @@ Jqo.field ~k:"peer_id" identity_json
-  in
-  let secondary_client =
-    Tezos_client.of_node ~exec:client_exec secondary_node
-  in
-  let* connections_json =
-    Tezos_client.rpc
-      state
-      ~client:secondary_client
-      `Get
-      ~path:"/network/connections/"
-  in
-  let are_nodes_connected =
-    Jqo.list_exists
-      ~f:(fun connection ->
-        let peer_id =
-          Ezjsonm.value_to_string @@ Jqo.field ~k:"peer_id" connection
-        in
-        String.equal primary_node_peer_id peer_id)
-      connections_json
-  in
-  let* () =
-    match (should_synch, are_nodes_connected) with
-    | true, false -> fail (`Scenario_error "Expecting nodes to be connected")
-    | false, true ->
-        fail (`Scenario_error "Expecting nodes to not be connected")
-    | _ -> return ()
-  in
-  let* json =
-    Stdlib.Scanf.sscanf primary_node_peer_id "%S" (fun primary_node_peer_id ->
-        Tezos_client.rpc
-          state
-          ~client:secondary_client
-          `Get
-          ~path:(sprintf "/network/peers/%s/banned" primary_node_peer_id))
-  in
-  let is_banned = Ezjsonm.get_bool json in
-  if is_banned then fail (`Scenario_error "Node should not be banned")
-  else return ()
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let hm_arg =
-    Arg.enum [("archive", `Archive); ("full", `Full 5); ("rolling", `Rolling 5)]
-  in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"node-synchronization"
-      ()
-  in
-  let term, info =
-    Test_command_line.Run_command.make
-      ~pp_error
-      (const
-         (fun
-           node_exec
-           client_exec
-           primary_history_mode
-           secondary_history_mode
-           should_synch
-           state
-         ->
-           ( state,
-             Interactive_test.Pauser.run_test
-               ~pp_error
-               state
-               (run
-                  state
-                  ~node_exec
-                  ~client_exec
-                  ~primary_history_mode
-                  ~secondary_history_mode
-                  ~should_synch) ))
-      $ Tezos_executable.cli_term base_state `Node "tezos"
-      $ Tezos_executable.cli_term base_state `Client "tezos"
-      $ Arg.(
-          value
-          & opt hm_arg (`Full 5)
-          & info
-              ["primary-history-mode"]
-              ~docv:"STRING"
-              ~doc:
-                (sprintf
-                   "History mode of the primary node. This one lonely bakes %d \
-                    blocks."
-                   number_of_lonely_bakes))
-      $ Arg.(
-          value
-          & opt hm_arg (`Full 5)
-          & info
-              ["secondary-history-mode"]
-              ~docv:"STRING"
-              ~doc:
-                (sprintf
-                   "History mode of the secondary node. This one tries to \
-                    bootstrap after the primary node lonely bakes %d blocks."
-                   number_of_lonely_bakes))
-      $ Arg.(
-          value & opt bool true
-          & info
-              ["should-synch"]
-              ~docv:"BOOL"
-              ~doc:
-                "Specify if the nodes should be synchronized after the lonely \
-                 baking run.")
-      $ Test_command_line.cli_state ~name:"history_mode_synchronization" ())
-      (let doc =
-         sprintf
-           "Synchronization of two sandboxed nodes after a lonely baking run \
-            of %d blocks."
-           number_of_lonely_bakes
-       in
-       let man : Manpage.block list =
-         [
-           `S "NODE SYNCHRONIZATION";
-           `P
-             (sprintf
-                "This command builds a network of two interconnected nodes N1 \
-                 and N2. The test first waits for synchronization of both \
-                 nodes after N1 bakes %d blocks, it then kills N2, makes N1 \
-                 lonely bake %d blocks and restarts N2. Finally, the test \
-                 verifies if N2 is bootstrapped, and that N1 is not considered \
-                 as a banned peer by N2. Depending on the specified history \
-                 modes, N1 may or not bootstrap N2, the expected result is \
-                 provided by the 'should-synch' command argument."
-                starting_level
-                number_of_lonely_bakes);
-         ]
-       in
-       Cmd.info ~man ~doc "node-synchronization")
-  in
-  Cmd.v info term
diff --git a/src/bin_sandbox/command_prevalidation.ml b/src/bin_sandbox/command_prevalidation.ml
deleted file mode 100644
index 1b2e6a24660f518f3de3f46c46b757b5500f51d3..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_prevalidation.ml
+++ /dev/null
@@ -1,48 +0,0 @@
-open Flextesa
-open Internal_pervasives
-open Console
-
-let run state node_exec client_exec () =
-  let* nodes, _protocol =
-    Test_scenario.network_with_protocol ~size:2 state ~node_exec ~client_exec
-  in
-  match nodes with
-  | [] | [_] | _ :: _ :: _ :: _ -> assert false
-  | [n1; n2] ->
-      let c1 = Tezos_client.of_node ~exec:client_exec n1 in
-      let c2 = Tezos_client.of_node ~exec:client_exec n2 in
-      (* TODO: helpers for
-         - injecting an op
-         - displaying the mempool
-         - setting filter plugin config
-
-         TODO: non-interactive test for propagation
-         TODO: commands for interactive use *)
-      Stdlib.ignore c1 ;
-      Stdlib.ignore c2 ;
-      let commands = Interactive_test.Commands.all_defaults state ~nodes in
-      let* () = Prompt.command state ~commands in
-      Running_processes.wait_all state
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"prevalidation"
-      ()
-  in
-  let term =
-    const (fun bnod bcli state ->
-        Test_command_line.Run_command.or_hard_fail
-          state
-          ~pp_error
-          (run state bnod bcli))
-    $ Tezos_executable.cli_term base_state `Node "tezos"
-    $ Tezos_executable.cli_term base_state `Client "tezos"
-    $ Test_command_line.cli_state ~name:"prevalidation" ()
-  in
-  let info = Cmd.info ~doc:"Work-in-progress." "prevalidation" in
-  Cmd.v info term
diff --git a/src/bin_sandbox/command_voting.ml b/src/bin_sandbox/command_voting.ml
deleted file mode 100644
index 4732beab0180f756f6e95c86db228f023df49b97..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/command_voting.ml
+++ /dev/null
@@ -1,1039 +0,0 @@
-(* Semi-interactive test for voting *)
-open Flextesa
-open Internal_pervasives
-module Counter_log = Helpers.Counter_log
-
-let ledger_prompt_notice state ef =
-  Console.say
-    state
-    EF.(
-      desc
-        (shout "Ledger-prompt")
-        (list [ef; wf "Please hit “✔” on the ledger."]))
-
-let setup_baking_ledger state uri ~client =
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          wf "Setting up the ledger device %S" uri;
-          haf
-            "Please make sure the ledger is on the Baking app and quit (`q`) \
-             this prompt to continue.";
-        ]
-      ~force:true
-  in
-  let key_name = "ledgered" in
-  let baker = Tezos_client.Keyed.make client ~key_name ~secret_key:uri in
-  let* () =
-    ledger_prompt_notice
-      state
-      EF.(
-        wf
-          "Importing %S in client `%s`. The ledger should be prompting for \
-           acknowledgment to provide the public key."
-          uri
-          client.Tezos_client.id)
-  in
-  let* _ = Tezos_client.Keyed.initialize state baker in
-  let* () =
-    ledger_prompt_notice
-      state
-      EF.(
-        wf
-          "Setting up %S for baking. The ledger should be showing the setup \
-           parameters (Address, Main chain, HWMs)."
-          uri)
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client
-      [
-        "setup";
-        "ledger";
-        "to";
-        "bake";
-        "for";
-        key_name;
-        "--main-hwm";
-        "0";
-        "--test-hwm";
-        "0";
-      ]
-  in
-  return baker
-
-let failf fmt = ksprintf (fun s -> fail (`Scenario_error s)) fmt
-
-let transfer state ~client ~src ~dst ~amount =
-  Tezos_client.successful_client_cmd
-    state
-    ~client
-    [
-      "--wait";
-      "none";
-      "transfer";
-      sprintf "%Ld" amount;
-      "from";
-      src;
-      "to";
-      dst;
-      "--fee";
-      "0.05";
-      "--burn-cap";
-      "0.3";
-    ]
-
-let register state ~client ~dst =
-  Tezos_client.successful_client_cmd
-    state
-    ~client
-    ["--wait"; "none"; "register"; "key"; dst; "as"; "delegate"]
-
-let bake_until_voting_period ?keep_alive_delegate state ~protocol ~baker
-    ~attempts period =
-  let is_expected_period (voting_period : (string * Ezjsonm.value) list)
-      period_name =
-    match Stdlib.List.assoc_opt "voting_period" voting_period with
-    | Some (`O obj) -> (
-        match Stdlib.List.assoc_opt "kind" obj with
-        | Some (`String p) -> String.equal p period_name
-        | _ -> false)
-    | _ -> false
-  in
-  let client = baker.Tezos_client.Keyed.client in
-  let period_name = Tezos_protocol.voting_period_to_string protocol period in
-  Helpers.wait_for state ~attempts ~seconds:0.5 (fun nth ->
-      let* json =
-        Tezos_client.rpc
-          state
-          ~client
-          `Get
-          ~path:"/chains/main/blocks/head/votes/current_period"
-      in
-      match json with
-      | `O voting_period when is_expected_period voting_period period_name ->
-          return (`Done (nth - 1))
-      | _ ->
-          let* _ =
-            Asynchronous_result.map_option keep_alive_delegate ~f:(fun dst ->
-                register state ~client ~dst)
-          in
-          let* () =
-            ksprintf
-              (Tezos_client.Keyed.bake state baker)
-              "Baker %s bakes %d/%d waiting for %S voting period"
-              client.id
-              nth
-              attempts
-              period_name
-          in
-          return (`Not_done (sprintf "Waiting for %S period" period_name)))
-
-let check_understood_protocols state ~chain ~client ~protocol_hash
-    ~expect_clueless_client =
-  Asynchronous_result.bind_on_result
-    (Tezos_client.successful_client_cmd
-       state
-       ~client
-       ["--chain"; chain; "list"; "understood"; "protocols"])
-    ~f:(function
-      | Ok client_protocols_result -> (
-          match
-            List.find client_protocols_result#out ~f:(fun prefix ->
-                String.is_prefix protocol_hash ~prefix)
-          with
-          | Some _ -> return `Proper_understanding
-          | None when expect_clueless_client ->
-              return `Expected_misunderstanding
-          | None -> return `Failure_to_understand)
-      | Error (`Process_error _) when expect_clueless_client ->
-          return `Expected_misunderstanding
-      | Error e -> fail e)
-
-let run state ~winner_path ~demo_path ~protocol ~node_exec ~client_exec
-    ~clueless_winner ~admin_exec ~winner_client_exec ~size ~base_port
-    ~serialize_proposals ?with_ledger () =
-  let default_attempts = 50 in
-  let* () = Helpers.clear_root state in
-  let* () =
-    Helpers.System_dependencies.precheck
-      state
-      `Or_fail
-      ~executables:[node_exec; client_exec; admin_exec; winner_client_exec]
-      ~protocol_paths:[winner_path; demo_path]
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Ready to start"; af "Root path deleted."]
-  in
-  let protocol, baker_0_account, baker_0_balance =
-    let open Tezos_protocol in
-    let baker = List.nth_exn protocol.bootstrap_accounts 0 in
-    ( {
-        protocol with
-        time_between_blocks = [1; 0];
-        minimal_block_delay = 1;
-        bootstrap_accounts =
-          List.map protocol.bootstrap_accounts ~f:(fun (n, v) ->
-              if Poly.(fst baker = n) then (n, v) else (n, 1_000L));
-      },
-      fst baker,
-      snd baker )
-  in
-  let* nodes, protocol =
-    Test_scenario.network_with_protocol
-      ~protocol
-      ~size
-      ~base_port
-      state
-      ~node_exec
-      ~client_exec
-  in
-  let make_admin = Tezos_admin_client.of_client ~exec:admin_exec in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.(
-      all_defaults state ~nodes
-      @ [secret_keys state ~protocol; Log_recorder.Operations.show_all state]
-      @ arbitrary_commands_for_each_and_all_clients
-          state
-          ~make_admin
-          ~clients:(List.map nodes ~f:(Tezos_client.of_node ~exec:client_exec))) ;
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "About to really start playing"]
-  in
-  let client n =
-    Tezos_client.of_node ~exec:client_exec (List.nth_exn nodes n)
-  in
-  let baker_0 =
-    Tezos_client.Keyed.make
-      (client 0)
-      ~key_name:"baker-0"
-      ~secret_key:(Tezos_protocol.Account.private_key baker_0_account)
-  in
-  let* _ = Tezos_client.Keyed.initialize state baker_0 in
-  let level_counter = Counter_log.create () in
-  let first_bakes = 5 in
-  let* () =
-    Loop.n_times first_bakes (fun nth ->
-        ksprintf (Tezos_client.Keyed.bake state baker_0) "initial-bake %d" nth)
-  in
-  let initial_level = first_bakes + 1 in
-  Counter_log.add level_counter "initial_level" initial_level ;
-  let* special_baker =
-    match with_ledger with
-    | None ->
-        let* () = Console.say state EF.(wf "No ledger.") in
-        let account = Tezos_protocol.Account.of_name "special-baker" in
-        let baker =
-          Tezos_client.Keyed.make
-            (client 0)
-            ~key_name:(Tezos_protocol.Account.name account)
-            ~secret_key:(Tezos_protocol.Account.private_key account)
-        in
-        let* _ = Tezos_client.Keyed.initialize state baker in
-        return baker
-    | Some uri -> setup_baking_ledger state ~client:(client 0) uri
-  in
-  let winner_client = {baker_0.client with exec = winner_client_exec} in
-  let winner_baker_0 =
-    let open Tezos_client.Keyed in
-    {baker_0 with client = winner_client}
-  in
-  let winner_special_baker =
-    let open Tezos_client.Keyed in
-    {special_baker with client = winner_client}
-  in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.
-      [
-        arbitrary_command_on_all_clients
-          state
-          ~command_names:["wc"; "winner-client"]
-          ?make_admin:None
-          ~clients:[winner_client];
-      ] ;
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[wf "You can now try the new-client"]
-  in
-  Interactive_test.Pauser.add_commands
-    state
-    Interactive_test.Commands.
-      [
-        arbitrary_command_on_all_clients
-          state
-          ~command_names:["baker"]
-          ~make_admin
-          ~clients:[special_baker.Tezos_client.Keyed.client];
-      ] ;
-  let* res =
-    transfer
-      state (* Tezos_client.successful_client_cmd state *)
-      ~client:(client 0)
-      ~amount:(Int64.( / ) baker_0_balance 2_000_000L)
-      ~src:"baker-0"
-      ~dst:special_baker.Tezos_client.Keyed.key_name
-  in
-  let* () =
-    Console.say
-      state
-      EF.(
-        desc
-          (wf "Successful transfer baker-0 -> special:")
-          (ocaml_string_list res#out))
-  in
-  let after_transfer_bakes = 2 in
-  let* () =
-    Loop.n_times after_transfer_bakes (fun nth ->
-        ksprintf
-          (Tezos_client.Keyed.bake state baker_0)
-          "after-transfer-bake %d"
-          nth)
-  in
-  Counter_log.add level_counter "after-transfer-bakes" after_transfer_bakes ;
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      nodes
-      (`At_least (Counter_log.sum level_counter))
-  in
-  let* (_ : unit option) =
-    Asynchronous_result.map_option with_ledger ~f:(fun _ ->
-        ledger_prompt_notice state EF.(wf "Registering as delegate."))
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:(client 0)
-      [
-        "--wait";
-        "none";
-        "reveal";
-        "key";
-        "for";
-        special_baker.Tezos_client.Keyed.key_name;
-        "--fee";
-        "0.1";
-      ]
-  in
-  let* _ =
-    Tezos_client.Keyed.bake state baker_0 "Bake to reveal special_baker key"
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:(client 0)
-      [
-        "--wait";
-        "none";
-        "register";
-        "key";
-        special_baker.Tezos_client.Keyed.key_name;
-        "as";
-        "delegate";
-        "--fee";
-        "0.4";
-      ]
-  in
-  let activation_bakes =
-    let open Tezos_protocol in
-    protocol.blocks_per_cycle * (protocol.preserved_cycles + 2)
-  in
-  let* () =
-    Loop.n_times activation_bakes (fun nth ->
-        let* () =
-          ksprintf
-            (Tezos_client.Keyed.bake state baker_0)
-            "Baking after new delegate registered: %d/%d"
-            nth
-            activation_bakes
-        in
-        let* res =
-          Tezos_client.successful_client_cmd
-            state
-            ~client:(client 0)
-            ["rpc"; "get"; "/chains/main/blocks/head/helpers/baking_rights"]
-        in
-        Console.say
-          state
-          EF.(
-            desc
-              (haf "Baking rights")
-              (markdown_verbatim (String.concat ~sep:"\n" res#out))))
-  in
-  Counter_log.add level_counter "activation-bakes" activation_bakes ;
-  let* () =
-    Tezos_client.Keyed.bake state special_baker "Baked by Special Baker™"
-  in
-  Counter_log.incr level_counter "special-baker-first-bake" ;
-  let attempts =
-    Tezos_protocol.(
-      (* If we are right after the proposal period, we need to get to
-         the next one *)
-      3 * protocol.blocks_per_voting_period)
-  in
-  let* extra_bakes_waiting_for_proposal_period =
-    bake_until_voting_period
-      state
-      ~protocol
-      ~baker:special_baker
-      ~attempts
-      `Proposal
-      ~keep_alive_delegate:baker_0.key_name
-  in
-  Counter_log.add
-    level_counter
-    "wait-for-proposal-period"
-    extra_bakes_waiting_for_proposal_period ;
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      nodes
-      (`At_least (Counter_log.sum level_counter))
-  in
-  let admin_0 = Tezos_admin_client.of_client ~exec:admin_exec (client 0) in
-  let* res =
-    Tezos_admin_client.successful_command admin_0 state ["list"; "protocols"]
-  in
-  let default_protocols = res#out in
-  let make_and_inject_protocol ?(make_different = false) name path =
-    let tmpdir = Paths.root state // sprintf "protocol-%s" name in
-    let* () = Console.say state EF.(wf "Injecting protocol from %s" tmpdir) in
-    let* _ =
-      Running_processes.run_successful_cmdf
-        state
-        "cp -L -R %s %s"
-        (Caml.Filename.quote path)
-        (Caml.Filename.quote tmpdir)
-    in
-    let* () =
-      if make_different then
-        let* _ =
-          Running_processes.run_successful_cmdf
-            state
-            "echo '(* Protocol %s *)' >> %s/main.mli"
-            name
-            (Caml.Filename.quote tmpdir)
-        in
-        return ()
-      else return ()
-    in
-    let* res, hash =
-      Tezos_admin_client.inject_protocol admin_0 state ~path:tmpdir
-    in
-    let* () =
-      Interactive_test.Pauser.generic
-        state
-        EF.
-          [
-            af "Just injected %s (%s): %s" name path hash;
-            markdown_verbatim (String.concat ~sep:"\n" res#out);
-          ]
-    in
-    return hash
-  in
-  let* winner_hash = make_and_inject_protocol "winner" winner_path in
-  let* demo_hash =
-    make_and_inject_protocol
-      ~make_different:Poly.(winner_path = demo_path)
-      "demo"
-      demo_path
-  in
-  let* res =
-    Tezos_admin_client.successful_command admin_0 state ["list"; "protocols"]
-  in
-  let after_injections_protocols = res#out in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          af "Network up";
-          desc (haf "Protocols")
-          @@ list
-               (List.map after_injections_protocols ~f:(fun p ->
-                    af
-                      "`%s` (%s)"
-                      p
-                      (if List.mem default_protocols p ~equal:String.equal then
-                       "previously known"
-                      else
-                        match p with
-                        | _ when String.equal p winner_hash -> "injected winner"
-                        | _ when String.equal p demo_hash -> "injected demo"
-                        | _ -> "injected unknown")));
-        ]
-  in
-  let* (_ : unit option) =
-    Asynchronous_result.map_option with_ledger ~f:(fun _ ->
-        Interactive_test.Pauser.generic
-          state
-          EF.
-            [
-              af "About to VOTE";
-              haf "Please switch to the Wallet app and quit (`q`) this prompt.";
-            ]
-          ~force:true)
-  in
-  let submit_proposals baker props =
-    let* _ =
-      Asynchronous_result.map_option with_ledger ~f:(fun _ ->
-          ledger_prompt_notice
-            state
-            EF.(
-              wf
-                "Submitting proposal%s: %s"
-                (match props with [_] -> "" | _ -> "s")
-                (String.concat ~sep:", " props)))
-    in
-    let* _ =
-      Tezos_client.successful_client_cmd
-        state
-        ~client:baker.Tezos_client.Keyed.client
-        (["submit"; "proposals"; "for"; baker.key_name] @ props)
-    in
-    return ()
-  in
-  let to_submit_first = [winner_hash; demo_hash] in
-  let* () =
-    match serialize_proposals with
-    | false -> submit_proposals special_baker to_submit_first
-    | true ->
-        List_sequential.iter to_submit_first ~f:(fun one ->
-            submit_proposals special_baker [one])
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:baker_0.client
-      ["submit"; "proposals"; "for"; baker_0.key_name; winner_hash]
-  in
-  let* extra_bakes_waiting_for_exploration_period =
-    bake_until_voting_period
-      state
-      ~protocol
-      ~baker:baker_0
-      ~attempts:protocol.blocks_per_voting_period
-      `Exploration
-      ~keep_alive_delegate:special_baker.key_name
-  in
-  Counter_log.add
-    level_counter
-    "wait-for-exploration-period"
-    extra_bakes_waiting_for_exploration_period ;
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      nodes
-      (`At_least (Counter_log.sum level_counter))
-  in
-  let* () =
-    Helpers.wait_for state ~attempts:default_attempts ~seconds:2. (fun _ ->
-        let* current_proposal_json =
-          Tezos_client.rpc
-            state
-            ~client:(client 1)
-            `Get
-            ~path:"/chains/main/blocks/head/votes/current_proposal"
-        in
-        if Poly.(current_proposal_json <> `String winner_hash) then
-          return
-            (`Not_done
-              (sprintf
-                 "Waiting for current_proposal_json to be %s (%s)"
-                 winner_hash
-                 Ezjsonm.(to_string (wrap current_proposal_json))))
-        else return (`Done ()))
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:baker_0.client
-      ["submit"; "ballot"; "for"; baker_0.key_name; winner_hash; "yay"]
-  in
-  let* (_ : unit option) =
-    Asynchronous_result.map_option with_ledger ~f:(fun _ ->
-        ledger_prompt_notice
-          state
-          EF.(wf "Submitting “Yes” ballot for %S" winner_hash))
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:special_baker.client
-      ["submit"; "ballot"; "for"; special_baker.key_name; winner_hash; "yay"]
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Ballots are in (not baked though)"]
-  in
-  let* extra_bakes_waiting_for_cooldown_period =
-    bake_until_voting_period
-      state
-      ~protocol
-      ~baker:baker_0
-      ~attempts:(1 + protocol.blocks_per_voting_period)
-      ~keep_alive_delegate:special_baker.key_name
-      `Cooldown
-  in
-  Counter_log.add
-    level_counter
-    "wait-for-cooldown-period"
-    extra_bakes_waiting_for_cooldown_period ;
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      nodes
-      (`At_least (Counter_log.sum level_counter))
-  in
-  let* c =
-    check_understood_protocols
-      state
-      ~client:winner_client
-      ~chain:"main"
-      ~protocol_hash:winner_hash
-      ~expect_clueless_client:clueless_winner
-  in
-  let* () =
-    match c with
-    | `Proper_understanding ->
-        Interactive_test.Pauser.generic
-          state
-          EF.[wf "Cooldown period, with proper winner-client, have fun."]
-    | `Expected_misunderstanding ->
-        Console.say
-          state
-          EF.(wf "Winner-Client does know new protocol (expected)")
-    | `Failure_to_understand -> failf "Winner-Client does know new protocol!"
-  in
-  let* extra_bakes_waiting_for_promotion_period =
-    bake_until_voting_period
-      state
-      ~protocol
-      ~baker:baker_0
-      ~attempts:(1 + protocol.blocks_per_voting_period)
-      ~keep_alive_delegate:special_baker.key_name
-      `Promotion
-  in
-  Counter_log.add
-    level_counter
-    "wait-for-promotion-period"
-    extra_bakes_waiting_for_promotion_period ;
-  let* () =
-    Test_scenario.Queries.wait_for_all_levels_to_be
-      state
-      ~attempts:default_attempts
-      ~seconds:8.
-      nodes
-      (`At_least (Counter_log.sum level_counter))
-  in
-  let* () = Interactive_test.Pauser.generic state EF.[haf "Before ballots"] in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:baker_0.client
-      ["submit"; "ballot"; "for"; baker_0.key_name; winner_hash; "yay"]
-  in
-  let* (_ : unit option) =
-    Asynchronous_result.map_option with_ledger ~f:(fun _ ->
-        let* () =
-          Interactive_test.Pauser.generic
-            state
-            EF.
-              [
-                af "About to cast approval ballot.";
-                haf
-                  "Please switch back to the Wallet app and quit (`q`) this \
-                   prompt.";
-              ]
-            ~force:true
-        in
-        ledger_prompt_notice
-          state
-          EF.(wf "Submitting “Yes” ballot for %S" winner_hash))
-  in
-  let* _ =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:special_baker.client
-      ["submit"; "ballot"; "for"; special_baker.key_name; winner_hash; "yay"]
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.[af "Final ballot(s) are in (not baked though)"]
-  in
-  let ballot_bakes = 1 in
-  let* () =
-    Loop.n_times ballot_bakes (fun _ ->
-        Tezos_client.Keyed.bake state baker_0 "Baking the promotion ballots")
-  in
-  Counter_log.add level_counter "bake-the-ballots" ballot_bakes ;
-  let* client_protocols_result =
-    Tezos_client.successful_client_cmd
-      state
-      ~client:(client 0)
-      ["list"; "understood"; "protocols"]
-  in
-  let* () =
-    Interactive_test.Pauser.generic
-      state
-      EF.
-        [
-          af "Final ballot(s) are baked in.";
-          af
-            "The client `%s` understands the following protocols: %s"
-            Tezos_executable.(
-              Option.value
-                ~default:(default_binary client_exec)
-                client_exec.binary)
-            (String.concat ~sep:", " client_protocols_result#out);
-        ]
-  in
-  let* () =
-    match protocol.kind with
-    | `Alpha ->
-        Loop.n_times protocol.blocks_per_voting_period (fun _ ->
-            Tezos_client.Keyed.bake state baker_0 "Baking to Adoption period")
-    | _ -> return ()
-  in
-  let* extra_bakes_waiting_for_next_protocol =
-    Helpers.wait_for
-      state
-      ~seconds:0.5
-      ~attempts:(1 + protocol.blocks_per_voting_period)
-      (fun nth ->
-        let client = baker_0.client in
-        let* curl_res =
-          Running_processes.run_successful_cmdf
-            state
-            "curl http://localhost:%d/chains/main/blocks/head/metadata"
-            client.port
-        in
-        let json_string = curl_res#out |> String.concat ~sep:"\n" in
-        let json_metadata = Ezjsonm.from_string json_string in
-        match Jqo.field json_metadata ~k:"next_protocol" with
-        | `String p when String.equal p winner_hash -> return (`Done (nth - 1))
-        | other ->
-            let* _ =
-              transfer
-                state
-                ~client
-                ~amount:1L
-                ~src:baker_0.Tezos_client.Keyed.key_name
-                ~dst:special_baker.Tezos_client.Keyed.key_name
-            in
-            let* () =
-              ksprintf
-                (Tezos_client.Keyed.bake state baker_0)
-                "Baker %s bakes %d/%d waiting for next protocol: %S"
-                client.id
-                nth
-                attempts
-                winner_hash
-            in
-            return
-              (`Not_done
-                (sprintf
-                   "Waiting for next_protocol: %S (≠ %s)"
-                   winner_hash
-                   Ezjsonm.(to_string (wrap other)))))
-  in
-  Counter_log.add
-    level_counter
-    "wait-for-next-protocol"
-    extra_bakes_waiting_for_next_protocol ;
-  let* c =
-    check_understood_protocols
-      state
-      ~client:winner_client
-      ~chain:"main"
-      ~protocol_hash:winner_hash
-      ~expect_clueless_client:clueless_winner
-  in
-  let* () =
-    match c with
-    | `Expected_misunderstanding ->
-        Console.say
-          state
-          EF.(wf "As expected, the client does not know about %s" winner_hash)
-    | `Failure_to_understand ->
-        failf "The winner-client does not know about `%s`" winner_hash
-    | `Proper_understanding -> (
-        let* () =
-          Console.say state EF.(wf "The client knows about %s" winner_hash)
-        in
-        (* This actually depends on the protocol upgrade. *)
-        let* () =
-          Asynchronous_result.bind_on_result
-            (Tezos_client.successful_client_cmd
-               state
-               ~client:winner_client
-               ["upgrade"; "baking"; "state"])
-            ~f:(function
-              | Ok _ -> return ()
-              | Error _ ->
-                  Console.say
-                    state
-                    EF.(
-                      desc
-                        (shout "Warning")
-                        (wf
-                           "Command `upgrade baking state` failed, but we keep \
-                            going with the baking.")))
-        in
-        let* (_ : unit option) =
-          Asynchronous_result.map_option with_ledger ~f:(fun _ ->
-              let* () =
-                Interactive_test.Pauser.generic
-                  state
-                  EF.
-                    [
-                      af "About to bake on the new winning protocol.";
-                      haf
-                        "Please switch to the Baking app and quit (`q`) this \
-                         prompt.";
-                    ]
-                  ~force:true
-              in
-              let* () =
-                Console.say state EF.(wf "Sleeping for a couple of seconds…")
-                (* USB thing is often slower than humans hitting `q` *)
-              in
-              System.sleep 4.)
-        in
-        let* () =
-          Tezos_client.Keyed.bake
-            state
-            winner_baker_0
-            "First bake on new protocol !!"
-        in
-        Counter_log.incr level_counter "baker-0-bakes-on-new-protocol" ;
-        let* () =
-          Tezos_client.Keyed.bake
-            state
-            winner_special_baker
-            "Second bake on new protocol !!"
-        in
-        Counter_log.incr level_counter "special-baker-bakes-on-new-protocol" ;
-        let* json_metadata =
-          Tezos_client.rpc
-            state
-            ~client:winner_client
-            `Get
-            ~path:"/chains/main/blocks/head/metadata"
-        in
-        match Jqo.field json_metadata ~k:"protocol" with
-        | `String p when String.equal p winner_hash -> return ()
-        | other ->
-            failf
-              "Protocol is not `%s` but `%s`"
-              winner_hash
-              Ezjsonm.(to_string (wrap other)))
-  in
-  Interactive_test.Pauser.generic
-    state
-    EF.
-      [
-        haf "End of the Voting test: SUCCESS \\o/";
-        desc
-          (af "Estimated level: %d" (Counter_log.sum level_counter))
-          (markdown_verbatim (Counter_log.to_table_string level_counter));
-      ]
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make
-      ~application_name:"Flextesa"
-      ~command_name:"voting"
-      ()
-  in
-  let docs = Manpage_builder.section_test_scenario base_state in
-  let term =
-    const
-      (fun
-        winner_path
-        demo_path
-        node_exec
-        client_exec
-        admin_exec
-        winner_client_exec
-        size
-        (`Clueless_winner clueless_winner)
-        (`Base_port base_port)
-        (`With_ledger with_ledger)
-        (`Serialize_proposals serialize_proposals)
-        protocol
-        state
-      ->
-        Test_command_line.Run_command.or_hard_fail
-          state
-          ~pp_error
-          (Interactive_test.Pauser.run_test
-             state
-             ~pp_error
-             (run
-                state
-                ~serialize_proposals
-                ~winner_path
-                ~clueless_winner
-                ~demo_path
-                ~node_exec
-                ~size
-                ~admin_exec
-                ~base_port
-                ~client_exec
-                ~winner_client_exec
-                ~protocol
-                ?with_ledger)))
-    $ Arg.(
-        const Caml.Filename.dirname
-        $ required
-            (pos
-               0
-               (some string)
-               None
-               (info
-                  ~docs
-                  []
-                  ~docv:"WINNER-PROTOCOL-PATH"
-                  ~doc:
-                    "The protocol to inject and make win the election, e.g. \
-                     `src/proto_004_Pt24m4xi/lib_protocol/src/TEZOS_PROTOCOL`.")))
-    $ Arg.(
-        const Caml.Filename.dirname
-        $ required
-            (pos
-               1
-               (some string)
-               None
-               (info
-                  ~docs
-                  []
-                  ~docv:"LOSER-PROTOCOL-PATH"
-                  ~doc:
-                    "The protocol to inject and down-vote, e.g. \
-                     `./src/bin_client/test/proto_test_injection/TEZOS_PROTOCOL` \
-                     (if same as `WINNER-PROTOCOL-PATH` the scenario will make \
-                     them automatically & artificially different).")))
-    $ Tezos_executable.cli_term base_state `Node "current"
-    $ Tezos_executable.cli_term base_state `Client "current"
-    $ Tezos_executable.cli_term base_state `Admin "current"
-    $ Tezos_executable.cli_term base_state `Client "winner"
-    $ Arg.(value (opt int 5 (info ["size"; "S"] ~doc:"Size of the Network.")))
-    $ Arg.(
-        const (fun b -> `Clueless_winner b)
-        $ value
-            (flag
-               (info
-                  ~docs
-                  ["winning-client-is-clueless"]
-                  ~doc:
-                    "Do not fail if the client does not know about “next” \
-                     protocol.")))
-    (*
-$ Arg.(
-        const (fun p -> `Hash p)
-        $ value
-            (opt
-               (some string)
-               None
-               (info
-                  ["current-hash"]
-                  ~doc:"The hash to advertise as the current protocol.")))
- *)
-    $ Arg.(
-        const (fun p -> `Base_port p)
-        $ value
-            (opt
-               int
-               46_000
-               (info ~docs ["base-port"] ~doc:"Base port number to build upon.")))
-    $ Arg.(
-        const (fun x -> `With_ledger x)
-        $ value
-            (opt
-               (some string)
-               None
-               (info
-                  ["with-ledger"]
-                  ~docs
-                  ~docv:"ledger://..."
-                  ~doc:
-                    "Do the test with a Ledger Nano device as one of the \
-                     bakers/voters.")))
-    $ Arg.(
-        const (fun x -> `Serialize_proposals x)
-        $ value
-            (flag
-               (info
-                  ["serialize-proposals"]
-                  ~docs
-                  ~doc:
-                    "Run the proposals one-by-one instead of all together \
-                     (preferred by the Ledger).")))
-    $ Tezos_protocol.cli_term base_state
-    $ Test_command_line.cli_state ~name:"voting" ()
-  in
-  let info =
-    let doc = "Sandbox network with a full round of voting." in
-    let man : Manpage.block list =
-      [
-        `S "VOTING TEST";
-        `P
-          "This command provides a test which uses a network sandbox to \
-           perform a full round of protocol vote and upgrade, including voting \
-           and baking on the test chain with or without a Ledger Nano device.";
-        `P "There are two main test behaviors:";
-        `P
-          "* $(b,SIMPLE:) The simple one does as much as possible with any \
-           dummy protocol candidates and a Tezos code-base which doesn't \
-           handle them: it tests all the voting periods until baking the last \
-           block of the currently understood protocol.";
-        `Noblank;
-        `P
-          "To allow the test to succeed in this case, the option \
-           `--winning-client-is-clueless` is required; it is meant to signal \
-           that the “winner” `tezos-client` executable (from the \
-           `--winner-client-binary` option) is expected to not understand the \
-           winning protocol.";
-        `Noblank;
-        `P "This is the version running in Gitlab-CI, see `bin_flextesa/dune`.";
-        `P
-          "* $(b,FULL:) Without the `--winning-client-is-clueless` option, the \
-           test will try to bake on the test chain as well as after the \
-           protocol switch (with the winner-client). This requires the winning \
-           protocol to be a working one and, of course, the winning-client to \
-           understand it.";
-        `P
-          "The test can run fully automated unless one uses the \
-           `\"--with-ledger=ledger://...\"` option in which case some steps \
-           have to be interactive. In this case, the option \
-           `--serialize-proposals` is recommended, because if it is not \
-           provided, the proposal vote will be a “Sign Unverified” operation.";
-      ]
-    in
-    Cmd.info ~doc ~man "voting"
-  in
-  Cmd.v info term
diff --git a/src/bin_sandbox/dune b/src/bin_sandbox/dune
deleted file mode 100644
index d4530fd51174a470b69b4b47605155a086acc94d..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/dune
+++ /dev/null
@@ -1,10 +0,0 @@
-; This file was automatically generated, do not edit.
-; Edit file manifest/main.ml instead.
-
-(executable
- (name main)
- (libraries
-  tezos-base
-  tezos-base.unix
-  fmt
-  flextesa))
diff --git a/src/bin_sandbox/main.ml b/src/bin_sandbox/main.ml
deleted file mode 100644
index d86a7e43aeed9c033879f8776ba22ac003a8dcd0..0000000000000000000000000000000000000000
--- a/src/bin_sandbox/main.ml
+++ /dev/null
@@ -1,103 +0,0 @@
-open Flextesa
-open Internal_pervasives
-
-module Small_utilities = struct
-  let key_of_name_command () =
-    let open Cmdliner in
-    let open Term in
-    let term =
-      const (fun n ->
-          let open Tezos_protocol.Account in
-          let account = of_name n in
-          Fmt.pr
-            "%s,%s,%s,%s\n%!"
-            (name account)
-            (pubkey account)
-            (pubkey_hash account)
-            (private_key account))
-      $ Arg.(
-          required
-            (pos
-               0
-               (some string)
-               None
-               (info [] ~docv:"NAME" ~doc:"String to generate the data from.")))
-    in
-    let info =
-      Cmd.info
-        "key-of-name"
-        ~doc:"Make an unencrypted key-pair deterministically from a string."
-        ~man:
-          [
-            `P
-              "`flextesa key-of-name hello-world` generates a key-pair of the \
-               `unencrypted:..` kind and outputs it as a 4 values separated by \
-               commas: `name,pub-key,pub-key-hash,private-uri` (hence \
-               compatible with the `--add-bootstrap-account` option of some of \
-               the test scenarios).";
-          ]
-    in
-    Cmd.v info term
-
-  let netstat_ports ~pp_error () =
-    let open Cmdliner in
-    let open Term in
-    let term, info =
-      Test_command_line.Run_command.make
-        ~pp_error
-        (const (fun state ->
-             ( state,
-               fun () ->
-                 let* ports = Helpers.Netstat.used_listening_ports state in
-                 let to_display =
-                   List.map ports ~f:(fun (p, _) -> p)
-                   |> List.sort ~compare:Int.compare
-                 in
-                 Console.sayf
-                   state
-                   Fmt.(
-                     hvbox ~indent:2 (fun ppf () ->
-                         box words ppf "Netstat listening ports:" ;
-                         sp ppf () ;
-                         box
-                           (list
-                              ~sep:(fun ppf () ->
-                                string ppf "," ;
-                                sp ppf ())
-                              (fun ppf p -> fmt "%d" ppf p))
-                           ppf
-                           to_display)) ))
-        $ Test_command_line.cli_state
-            ~disable_interactivity:true
-            ~name:"netstat-ports"
-            ())
-        (Cmd.info
-           "netstat-listening-ports"
-           ~doc:"Like `netstat -nut | awk something-something` but glorified.")
-    in
-    Cmd.v info term
-
-  let all ~pp_error () = [key_of_name_command (); netstat_ports ~pp_error ()]
-end
-
-let commands =
-  let open Cmdliner in
-  let help = Term.(ret (const (`Help (`Auto, None)))) in
-  let info = Cmd.info "help" in
-  let pp_error = Flextesa.Test_command_line.Common_errors.pp in
-  Cmd.group
-    ~default:help
-    info
-    (Small_utilities.all ~pp_error ()
-    @ [
-        Command_daemons_protocol_change.cmd ();
-        Command_voting.cmd ();
-        Command_accusations.cmd ();
-        Command_prevalidation.cmd ();
-        Command_ledger_baking.cmd ();
-        Command_ledger_wallet.cmd ();
-        Flextesa.Interactive_mini_network.cmd ();
-        Command_node_synchronization.cmd ();
-      ])
-
-let () = Caml.exit (Cmdliner.Cmd.eval commands)
diff --git a/src/proto_000_Ps9mPmXa/lib_protocol/dune b/src/proto_000_Ps9mPmXa/lib_protocol/dune
index 79f857ffd833f993046e2615ca5a042a18e67834..ed6adb17ff06c56afb685a8e6561c05e16c08afc 100644
--- a/src/proto_000_Ps9mPmXa/lib_protocol/dune
+++ b/src/proto_000_Ps9mPmXa/lib_protocol/dune
@@ -71,18 +71,6 @@
        main.ml main.mli (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_000_Ps9mPmXa.objs/native/tezos_protocol_000_Ps9mPmXa.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-000-Ps9mPmXa)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_000_Ps9mPmXa_functor)
  (libraries
diff --git a/src/proto_001_PtCJ7pwo/lib_protocol/dune b/src/proto_001_PtCJ7pwo/lib_protocol/dune
index df81b7cf7dc22339335729aa78cbb256694e63ee..ee20955f79e43409eb410871eab4e7e9c9388fdd 100644
--- a/src/proto_001_PtCJ7pwo/lib_protocol/dune
+++ b/src/proto_001_PtCJ7pwo/lib_protocol/dune
@@ -269,18 +269,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_001_PtCJ7pwo.objs/native/tezos_protocol_001_PtCJ7pwo.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-001-PtCJ7pwo)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_001_PtCJ7pwo_functor)
  (libraries
diff --git a/src/proto_002_PsYLVpVv/lib_protocol/dune b/src/proto_002_PsYLVpVv/lib_protocol/dune
index e62be7f99d4b0ac1d9d539de633cab790ace6ad9..be4f00bd7ba0ea1c496e41416bf3a67068556382 100644
--- a/src/proto_002_PsYLVpVv/lib_protocol/dune
+++ b/src/proto_002_PsYLVpVv/lib_protocol/dune
@@ -269,18 +269,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_002_PsYLVpVv.objs/native/tezos_protocol_002_PsYLVpVv.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-002-PsYLVpVv)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_002_PsYLVpVv_functor)
  (libraries
diff --git a/src/proto_003_PsddFKi3/lib_protocol/dune b/src/proto_003_PsddFKi3/lib_protocol/dune
index b01ffff8317c5147cadfda8bc5748a0cd0f808a6..368fc8f28fae8be90b2bdc630f2009ea2f3615a6 100644
--- a/src/proto_003_PsddFKi3/lib_protocol/dune
+++ b/src/proto_003_PsddFKi3/lib_protocol/dune
@@ -272,18 +272,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_003_PsddFKi3.objs/native/tezos_protocol_003_PsddFKi3.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-003-PsddFKi3)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_003_PsddFKi3_functor)
  (libraries
diff --git a/src/proto_004_Pt24m4xi/lib_protocol/dune b/src/proto_004_Pt24m4xi/lib_protocol/dune
index f30b692d35181b837553b099555a19c5a53008e4..0dd9b015298c6ba2c59624d483442ed929b9a4b5 100644
--- a/src/proto_004_Pt24m4xi/lib_protocol/dune
+++ b/src/proto_004_Pt24m4xi/lib_protocol/dune
@@ -272,18 +272,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_004_Pt24m4xi.objs/native/tezos_protocol_004_Pt24m4xi.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-004-Pt24m4xi)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_004_Pt24m4xi_functor)
  (libraries
diff --git a/src/proto_005_PsBABY5H/lib_protocol/dune b/src/proto_005_PsBABY5H/lib_protocol/dune
index 28f320e8c1dec57443c068fbbcfdff226f0ef6c4..6e3c40b05969214bfec8584734d0d47adfc84a61 100644
--- a/src/proto_005_PsBABY5H/lib_protocol/dune
+++ b/src/proto_005_PsBABY5H/lib_protocol/dune
@@ -275,18 +275,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_005_PsBABY5H.objs/native/tezos_protocol_005_PsBABY5H.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-005-PsBABY5H)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_005_PsBABY5H_functor)
  (libraries
diff --git a/src/proto_005_PsBabyM1/lib_protocol/dune b/src/proto_005_PsBabyM1/lib_protocol/dune
index 13f3e43a7a2b36e6abff15095594872baaa0da1f..062bb6e61ad465a02f0d82c8de92d0e3f9cd0c8e 100644
--- a/src/proto_005_PsBabyM1/lib_protocol/dune
+++ b/src/proto_005_PsBabyM1/lib_protocol/dune
@@ -275,18 +275,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_005_PsBabyM1.objs/native/tezos_protocol_005_PsBabyM1.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-005-PsBabyM1)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_005_PsBabyM1_functor)
  (libraries
diff --git a/src/proto_006_PsCARTHA/lib_protocol/dune b/src/proto_006_PsCARTHA/lib_protocol/dune
index 1c0a764409835d3058dc163025359405eee6bfeb..f93585fecb851e147c596ba2537f282df10f0cc2 100644
--- a/src/proto_006_PsCARTHA/lib_protocol/dune
+++ b/src/proto_006_PsCARTHA/lib_protocol/dune
@@ -275,18 +275,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_006_PsCARTHA.objs/native/tezos_protocol_006_PsCARTHA.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-006-PsCARTHA)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_006_PsCARTHA_functor)
  (libraries
diff --git a/src/proto_007_PsDELPH1/lib_protocol/dune b/src/proto_007_PsDELPH1/lib_protocol/dune
index ed10cae4931ba76b6325b0cb96e525a0f7afb1ca..0c35ec7ec487213769e6e02be6280cd119685529 100644
--- a/src/proto_007_PsDELPH1/lib_protocol/dune
+++ b/src/proto_007_PsDELPH1/lib_protocol/dune
@@ -281,18 +281,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_007_PsDELPH1.objs/native/tezos_protocol_007_PsDELPH1.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-007-PsDELPH1)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_007_PsDELPH1_functor)
  (libraries
diff --git a/src/proto_008_PtEdo2Zk/lib_protocol/dune b/src/proto_008_PtEdo2Zk/lib_protocol/dune
index d1b2a088e6b7b27dab8447e70110f9a9e80986cc..6ca589a80bfe9e644cd411dccfe818148240ecc2 100644
--- a/src/proto_008_PtEdo2Zk/lib_protocol/dune
+++ b/src/proto_008_PtEdo2Zk/lib_protocol/dune
@@ -296,18 +296,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_008_PtEdo2Zk.objs/native/tezos_protocol_008_PtEdo2Zk.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-008-PtEdo2Zk)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_008_PtEdo2Zk_functor)
  (libraries
diff --git a/src/proto_008_PtEdoTez/lib_protocol/dune b/src/proto_008_PtEdoTez/lib_protocol/dune
index 3f6548997e3edc9fe9344a305866a33994319db5..cd699728bef71f6a8d79219f9550a28cce0d41ca 100644
--- a/src/proto_008_PtEdoTez/lib_protocol/dune
+++ b/src/proto_008_PtEdoTez/lib_protocol/dune
@@ -296,18 +296,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_008_PtEdoTez.objs/native/tezos_protocol_008_PtEdoTez.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-008-PtEdoTez)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_008_PtEdoTez_functor)
  (libraries
diff --git a/src/proto_009_PsFLoren/lib_protocol/dune b/src/proto_009_PsFLoren/lib_protocol/dune
index 8537e9e6df9e0dfeede6187312b6239ff98ee75e..f845acd605736a781785805d9ad9ab48d78ff8b2 100644
--- a/src/proto_009_PsFLoren/lib_protocol/dune
+++ b/src/proto_009_PsFLoren/lib_protocol/dune
@@ -305,18 +305,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_009_PsFLoren.objs/native/tezos_protocol_009_PsFLoren.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-009-PsFLoren)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_009_PsFLoren_functor)
  (libraries
diff --git a/src/proto_010_PtGRANAD/lib_protocol/dune b/src/proto_010_PtGRANAD/lib_protocol/dune
index 0ccea78d1cf11d74034a27188e8b11c9ed7f232f..89ef9afc84bf918345b98306f8cd984bc1963f18 100644
--- a/src/proto_010_PtGRANAD/lib_protocol/dune
+++ b/src/proto_010_PtGRANAD/lib_protocol/dune
@@ -320,18 +320,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_010_PtGRANAD.objs/native/tezos_protocol_010_PtGRANAD.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-010-PtGRANAD)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_010_PtGRANAD_functor)
  (libraries
diff --git a/src/proto_011_PtHangz2/lib_protocol/dune b/src/proto_011_PtHangz2/lib_protocol/dune
index ac5b0b6701f60b9940509591e1c0cd3f923d67da..a877091933d71001aa0bd8a15b180558f8ffcf8a 100644
--- a/src/proto_011_PtHangz2/lib_protocol/dune
+++ b/src/proto_011_PtHangz2/lib_protocol/dune
@@ -359,18 +359,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_011_PtHangz2.objs/native/tezos_protocol_011_PtHangz2.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-011-PtHangz2)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_011_PtHangz2_functor)
  (libraries
diff --git a/src/proto_012_Psithaca/lib_protocol/dune b/src/proto_012_Psithaca/lib_protocol/dune
index 903eb32fe8db124addc681a436ba10236f35422d..cf583aba6a103b0b7184605edf9e3ac528fc8baf 100644
--- a/src/proto_012_Psithaca/lib_protocol/dune
+++ b/src/proto_012_Psithaca/lib_protocol/dune
@@ -410,18 +410,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_012_Psithaca.objs/native/tezos_protocol_012_Psithaca.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-012-Psithaca)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_012_Psithaca_functor)
  (libraries
diff --git a/src/proto_013_PtJakart/lib_protocol/dune b/src/proto_013_PtJakart/lib_protocol/dune
index 299a9f59a5ad4dee65d484ddff45aea0749a2b91..668dac8b6665f4d53708541ad3e25d461ce70418 100644
--- a/src/proto_013_PtJakart/lib_protocol/dune
+++ b/src/proto_013_PtJakart/lib_protocol/dune
@@ -607,18 +607,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_013_PtJakart.objs/native/tezos_protocol_013_PtJakart.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-013-PtJakart)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_013_PtJakart_functor)
  (libraries
diff --git a/src/proto_alpha/lib_protocol/dune b/src/proto_alpha/lib_protocol/dune
index 027974698992173be5cd39ba68b50493c8e66670..66f2ede09ba7f7af05f735bea4c02364bbbce4a7 100644
--- a/src/proto_alpha/lib_protocol/dune
+++ b/src/proto_alpha/lib_protocol/dune
@@ -666,17 +666,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} -no-hash-check .)))
 
-(rule
- (alias runtest_sandbox)
- (deps .tezos_protocol_alpha.objs/native/tezos_protocol_alpha.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-alpha)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_alpha_functor)
  (libraries
diff --git a/src/proto_demo_counter/lib_protocol/dune b/src/proto_demo_counter/lib_protocol/dune
index 01575880f2a1e9511c09bd04cf78a64d71a4462d..7db2c5c724ff12b5854a8445e272fa6877a628e2 100644
--- a/src/proto_demo_counter/lib_protocol/dune
+++ b/src/proto_demo_counter/lib_protocol/dune
@@ -95,18 +95,6 @@
   (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} -no-hash-check .)))
 
-(rule
- (alias runtest_sandbox)
- (deps
-  .tezos_protocol_demo_counter.objs/native/tezos_protocol_demo_counter.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-demo-counter)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_demo_counter_functor)
  (libraries
diff --git a/src/proto_demo_noops/lib_protocol/dune b/src/proto_demo_noops/lib_protocol/dune
index 385aa9eea7470181451e433e03133501907041c4..df7a83ac13eea089b8fbc4caf10452e739b0a1d3 100644
--- a/src/proto_demo_noops/lib_protocol/dune
+++ b/src/proto_demo_noops/lib_protocol/dune
@@ -67,17 +67,6 @@
  (deps main.ml main.mli (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} -no-hash-check .)))
 
-(rule
- (alias runtest_sandbox)
- (deps .tezos_protocol_demo_noops.objs/native/tezos_protocol_demo_noops.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-demo-noops)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_demo_noops_functor)
  (libraries
diff --git a/src/proto_genesis/lib_protocol/dune b/src/proto_genesis/lib_protocol/dune
index 6b08fb73c284e81ec5b5a51a20eca9dfd78f1ce6..c66c80f8a265d119073c6d829c94c8d4e9046898 100644
--- a/src/proto_genesis/lib_protocol/dune
+++ b/src/proto_genesis/lib_protocol/dune
@@ -71,17 +71,6 @@
        main.ml main.mli (:src_dir TEZOS_PROTOCOL))
  (action (run %{bin:tezos-protocol-compiler} -no-hash-check .)))
 
-(rule
- (alias runtest_sandbox)
- (deps .tezos_protocol_genesis.objs/native/tezos_protocol_genesis.cmx)
- (action (progn)))
-
-(rule
- (alias runtest)
- (package tezos-protocol-genesis)
- (deps (alias runtest_sandbox))
- (action (progn)))
-
 (library
  (name tezos_protocol_genesis_functor)
  (libraries
diff --git a/vendors/README.md b/vendors/README.md
index 1fed83b1552cf1a06db4c060ce0f86404ee99bb2..0f9bb7de334e8070af5a98a229a905d14d529324 100644
--- a/vendors/README.md
+++ b/vendors/README.md
@@ -51,25 +51,6 @@ None
 
 ## Misc
 
-### flextesa-lib
-- This library has no tests here; they are in the `tezos/flextesa` and not reproduced here.
-- Flextesa was initially developed to test 3rd party tools (Kiln, Dapps, etc.).
-  It was then integrated into Tezos to improve the testing infrastructure and
-  later, its development was re-externalized to the `tezos/flextesa` repository
-  to be more flexible. It is the base for the `tezos-sandbox` executable in
-  `src/bin_sandbox` and all the test scenarios defined in that `dune` file.
-- Cloned from: [flextesa](https://gitlab.com/tezos/flextesa), just the `src/lib`
-  sub-directory.
-- It is vendored because it
-  depends on some Tezos libraries (e.g. `tezos-crypto`), and it obviously makes
-  some assumptions on how Tezos works hence using `opam` would be too cumbersome
-  w.r.t. to changes in the protocol or the shell.
-
-#### Differences with the initial library
-
-Changes to the vendored version are periodically proposed in the main repository
-as merge-requests.
-
 ### ocaml-ledger-wallet
 - Library used by `tezos-client` to interact with the Ledger family of hardware
   wallets.
diff --git a/vendors/flextesa-lib/.ocamlformat b/vendors/flextesa-lib/.ocamlformat
deleted file mode 100644
index 6bafbd1c4e234b3b34aa76c3ce359274d0069922..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/.ocamlformat
+++ /dev/null
@@ -1 +0,0 @@
-profile=compact
diff --git a/vendors/flextesa-lib/console.ml b/vendors/flextesa-lib/console.ml
deleted file mode 100644
index 1ba48d853701bd15d0a287f941850725ffadc1b2..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/console.ml
+++ /dev/null
@@ -1,233 +0,0 @@
-open Internal_pervasives
-
-type t =
-  { color: bool
-  ; buffer: Buffer.t
-  ; channel: Lwt_io.output_channel
-  ; with_timestamp: bool
-  ; formatter: Caml.Format.formatter }
-
-let make with_timestamp color =
-  let channel = Lwt_io.stderr in
-  let b = Buffer.create 42 in
-  let formatter =
-    Caml.Format.make_formatter (Caml.Buffer.add_substring b) (fun () -> ())
-  in
-  let bold = "\027[01m" in
-  let red = "\027[31m" in
-  let reset = "\027[m" in
-  if color then (
-    let color_of_tag = function
-      | Caml.Format.String_tag "prompt" -> Some bold
-      | Caml.Format.String_tag "shout" -> Some red
-      | _ -> None in
-    Caml.Format.(
-      pp_set_formatter_stag_functions formatter
-        { mark_open_stag= (fun _ -> "")
-        ; mark_close_stag= (fun _ -> "")
-        ; print_open_stag=
-            (fun tag ->
-              match color_of_tag tag with
-              | Some c -> fprintf formatter "%s" c
-              | None -> ())
-        ; print_close_stag=
-            (fun tag ->
-              if Poly.(color_of_tag tag <> None) then
-                fprintf formatter "%s" reset) } ;
-      pp_set_tags formatter true) ) ;
-  {color; buffer= b; channel; formatter; with_timestamp}
-
-let pp fmt {color; _} = Fmt.pf fmt "@[<2>{Console:@ color: %b}@]" color
-
-let cli_term () =
-  let guess =
-    let dumb =
-      try match Caml.Sys.getenv "TERM" with "dumb" | "" -> true | _ -> false
-      with Caml.Not_found -> true in
-    let isatty = try Unix.(isatty stderr) with Unix.Unix_error _ -> false in
-    if (not dumb) && isatty then true else false in
-  Cmdliner.(
-    Term.(
-      pure make
-      $ Arg.(
-          value
-            (flag
-               (info ["with-timestamp"]
-                  ~doc:"Display messages with time-stamps.")))
-      $ Arg.(
-          pure (function `Y -> true | `N -> false | `G -> guess)
-          $
-          let answers = [("none", `N); ("yes", `Y); ("auto", `G)] in
-          let doc =
-            sprintf "Control terminal colors (%s)."
-              (String.concat ~sep:", " (List.map answers ~f:fst)) in
-          value & opt (enum answers) `G & info ["color"] ~doc)))
-
-let do_output t =
-  Lwt.(
-    fun () ->
-      Lwt_io.write t.channel (Buffer.contents t.buffer)
-      >>= fun () -> Buffer.clear t.buffer ; return_unit)
-
-let sayf (o : _ Base_state.t) (fmt : Caml.Format.formatter -> unit -> unit) :
-    (_, _) Asynchronous_result.t =
-  let date =
-    if o#console.with_timestamp then
-      let date =
-        Tezos_base.Time.System.now ()
-        |> Tezos_base.Time.System.to_notation in
-      sprintf "[%s]" date
-    else "" in
-  let ppf = o#console.formatter in
-  Caml.Format.(
-    pp_open_hvbox ppf 2 ;
-    pp_open_stag ppf (String_tag "prompt") ;
-    fprintf ppf "%s%s:" o#application_name date ;
-    pp_close_stag ppf () ;
-    pp_print_break ppf 2 0 ;
-    fmt ppf () ;
-    pp_print_newline ppf () ;
-    pp_close_box ppf () ;
-    pp_print_flush ppf ()) ;
-  System_error.catch (do_output o#console) ()
-
-let say (o : _ Base_state.t) ef : (_, _) Asynchronous_result.t =
-  let date =
-    if o#console.with_timestamp then
-      let date =
-        Tezos_base.Time.System.now ()
-        |> Tezos_base.Time.System.to_notation in
-      sprintf "[%s]" date
-    else "" in
-  let msg = EF.(label (ksprintf prompt "%s%s:" o#application_name date) ef) in
-  let fmt = o#console.formatter in
-  Caml.Format.(
-    fprintf fmt "%a" Easy_format.Pretty.to_formatter msg ;
-    pp_print_newline fmt () ;
-    pp_print_flush fmt ()) ;
-  System_error.catch (do_output o#console) ()
-
-module Prompt = struct
-  type item =
-    { commands: string list
-    ; description: string
-    ; details: unit Fmt.t option
-    ; action:
-           Base.Sexp.t list
-        -> ( [`Help | `Quit | `Loop]
-           , [System_error.t | `Command_line of string] )
-           Asynchronous_result.t }
-
-  let item ?details ~description commands action =
-    {commands; description; details; action}
-
-  let quit ?(description = "Quit this prompt and continue.") commands =
-    item ~description commands (fun _ -> return `Quit)
-
-  let help ?(description = "Display help on all commands.") commands =
-    item ~description commands (fun _ -> return `Help)
-
-  let unit_and_loop ?details ~description commands f =
-    item ?details ~description commands (fun x ->
-        f x >>= fun () -> return `Loop)
-
-  let default_commands () = [quit ["q"; "quit"]; help ["h"; "help"]]
-
-  let command ?(with_defaults = true) state ~commands =
-    let commands =
-      if with_defaults then default_commands () @ commands else commands in
-    let rec loop () =
-      say state EF.(af "Please enter command:")
-      >>= fun () ->
-      System_error.catch Lwt_io.read_line Lwt_io.stdin
-      >>= fun line ->
-      let open Base.Sexp in
-      match Parsexp.Single.parse_string (sprintf "( %s )" line) with
-      | Ok (List (Atom c :: more)) -> (
-        match
-          List.find commands ~f:(fun m ->
-              List.mem m.commands c ~equal:String.equal)
-        with
-        | Some {action; _} -> (
-            Asynchronous_result.bind_on_error
-              ( try action more
-                with e -> System_error.fail_fatalf "Exn: %a" Exn.pp e )
-              ~f:(fun ~result _ ->
-                say state
-                  EF.(
-                    desc (shout "Error in action:")
-                      (custom (fun ppf ->
-                           Attached_result.pp ppf result (* Error.pp ppf err *)
-                             ~pp_error:(fun fmt ->
-                             function
-                             | #System_error.t as e -> System_error.pp fmt e
-                             | `Command_line s ->
-                                 Fmt.pf fmt "Wrong command line: %s" s))))
-                >>= fun () -> return `Loop)
-            >>= function
-            | `Loop -> loop ()
-            | `Help ->
-                sayf state
-                  More_fmt.(
-                    fun ppf () ->
-                      vertical_box ~indent:2 ppf (fun ppf ->
-                          pf ppf "Available commands:" ;
-                          cut ppf () ;
-                          List.iter commands
-                            ~f:(fun {commands; description; details; _} ->
-                              wrapping_box ~indent:2 ppf (fun ppf ->
-                                  pf ppf "* {%a}:@ %a"
-                                    (list ~sep:(const string "|") (fun ppf s ->
-                                         prompt ppf (fun ppf -> string ppf s)))
-                                    commands text description ;
-                                  Option.iter details ~f:(fun pp ->
-                                      cut ppf () ; pp ppf ())) ;
-                              cut ppf ())))
-                >>= fun () -> loop ()
-            | `Quit -> return () )
-        | None ->
-            say state
-              EF.(
-                desc
-                  (ksprintf shout "Error, unknown command: %S" c)
-                  (custom (fun fmt ->
-                       Base.Sexp.pp_hum_indent 4 fmt (List more))))
-            >>= fun () -> loop () )
-      | Ok other ->
-          say state
-            EF.(
-              desc
-                (shout "Error, cannot understand: ")
-                (custom (fun fmt -> Base.Sexp.pp_hum_indent 4 fmt other)))
-          >>= fun () -> loop ()
-      | Error err ->
-          say state
-            EF.(
-              desc (shout "Error: ")
-                (custom (fun fmt ->
-                     Parsexp.Parse_error.report fmt ~filename:"<command-line>"
-                       err)))
-          >>= fun () -> loop () in
-    loop ()
-end
-
-let display_errors_of_command state ?(should_output = false) cmd =
-  let outputs () =
-    List.exists cmd#out ~f:Poly.(fun s -> String.strip s <> "") in
-  let success =
-    let unix_success = Poly.equal cmd#status (Lwt_unix.WEXITED 0) in
-    if should_output then unix_success && outputs () else unix_success in
-  ( if success then return ()
-  else
-    say state
-      EF.(
-        let output l =
-          match String.concat ~sep:"\n" l |> String.strip with
-          | "" -> af "NONE"
-          | more -> markdown_verbatim more in
-        desc (shout "Error:")
-          (list
-             [ haf "Command %s" (Process_result.status_to_string cmd#status)
-             ; desc (haf "Stdout:") (output cmd#out)
-             ; desc (haf "Stderr:") (output cmd#err) ])) )
-  >>= fun () -> return success
diff --git a/vendors/flextesa-lib/console.mli b/vendors/flextesa-lib/console.mli
deleted file mode 100644
index 5ae81f4ba4943db265f10f290ba6ec0637dfc75c..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/console.mli
+++ /dev/null
@@ -1,83 +0,0 @@
-(** Print messages, and prompt user input from the terminal. *)
-
-open Internal_pervasives
-
-type t =
-  { color: bool
-  ; buffer: Buffer.t
-  ; channel: Lwt_io.output_channel
-  ; with_timestamp: bool
-  ; formatter: Caml.Format.formatter }
-
-val make : bool -> bool -> t
-val pp : Caml.Format.formatter -> t -> unit
-
-val cli_term : unit -> t Cmdliner.Term.t
-(** {!Cmdliner.Term.t} which configures the console interaction
-    (e.g. the ["--color"] option). *)
-
-val say :
-     < application_name: string ; console: t ; .. >
-  -> Easy_format.t
-  -> (unit, [> System_error.t]) Asynchronous_result.t
-
-val sayf :
-     < application_name: string ; console: t ; .. >
-  -> (Caml.Format.formatter -> unit -> unit)
-  -> (unit, [> System_error.t]) Asynchronous_result.t
-
-(** Create interactive prompts. *)
-module Prompt : sig
-  type item = private
-    { commands: string list
-    ; description: string
-    ; details: unit Fmt.t option
-    ; action:
-           Sexplib0.Sexp.t list
-        -> ( [`Help | `Loop | `Quit]
-           , [`Command_line of string | System_error.t] )
-           Asynchronous_result.t }
-
-  val item :
-       ?details:unit Fmt.t
-    -> description:string
-    -> string list
-    -> (   Sexplib0.Sexp.t list
-        -> ( [`Help | `Loop | `Quit]
-           , [`Command_line of string | System_error.t] )
-           Asynchronous_result.t)
-    -> item
-  (** [item description command_aliases action] creates a command
-      which performs [action]; action gets all the arguments parsed as
-      S-Expressions. *)
-
-  val quit : ?description:string -> string list -> item
-  val help : ?description:string -> string list -> item
-
-  val unit_and_loop :
-       ?details:unit Fmt.t
-    -> description:string
-    -> string list
-    -> (   Sexplib0.Sexp.t list
-        -> ( unit
-           , [`Command_line of string | System_error.t] )
-           Asynchronous_result.t)
-    -> item
-
-  val default_commands : unit -> item list
-  (** The default commands are {!help} and {!quit}. *)
-
-  val command :
-       ?with_defaults:bool
-    -> < application_name: string ; console: t ; .. >
-    -> commands:item list
-    -> (unit, [> System_error.t]) Asynchronous_result.t
-  (** Prompt for a command among [~commnands]. *)
-end
-
-val display_errors_of_command :
-     < application_name: string ; console: t ; .. >
-  -> ?should_output:bool
-  -> < err: string list ; out: string list ; status: Unix.process_status ; .. >
-  -> (bool, [> System_error.t]) Asynchronous_result.t
-(** Display the results of a command if it fails (see {!Process_result.t}). *)
diff --git a/vendors/flextesa-lib/dump_files.ml b/vendors/flextesa-lib/dump_files.ml
deleted file mode 100644
index fed2103c89bb0bb8385062e68311a81e400b0c45..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/dump_files.ml
+++ /dev/null
@@ -1,29 +0,0 @@
-open Internal_pervasives
-module IFmt = More_fmt
-
-type t = {mutable trees: (string * string * (string * string) list) list}
-
-let make () = {trees= []}
-
-let write state ~name ~path files =
-  let t = state#dump_files in
-  Running_processes.run_successful_cmdf state "mkdir -p %s"
-    (Caml.Filename.quote path)
-  >>= fun _ ->
-  List_sequential.iter files ~f:(fun (p, content) ->
-      System.write_file state (path // p) ~content)
-  >>= fun () ->
-  (* Dbg.e EF.(wf "Adding %s" name) ; *)
-  t.trees <- (name, path, files) :: t.trees ;
-  return ()
-
-let pp ppf t =
-  (* Dbg.e EF.(wf "pp -ing %d" (List.length t.trees)) ; *)
-  IFmt.(
-    vertical_box ~indent:2 ppf (fun ppf ->
-        List.iter t.trees ~f:(fun (msg, path, files) ->
-            cut ppf () ;
-            pf ppf "%s setup at `%s`:" msg path ;
-            List.iter files ~f:(fun (p, c) ->
-                cut ppf () ;
-                pf ppf "* `./%s` → `%s`" p c))))
diff --git a/vendors/flextesa-lib/dump_files.mli b/vendors/flextesa-lib/dump_files.mli
deleted file mode 100644
index 1a59f366e951f8f49ab8a38cd3e4502ec29890f3..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/dump_files.mli
+++ /dev/null
@@ -1,21 +0,0 @@
-(** Write little file trees, and save them in the state. *)
-
-open Internal_pervasives
-
-type t = private
-  {mutable trees: (string * string * (string * string) list) list}
-
-val make : unit -> t
-
-val write :
-     < application_name: string
-     ; dump_files: t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> name:string
-  -> path:string
-  -> (string * string) list
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-
-val pp : t Fmt.t
diff --git a/vendors/flextesa-lib/dune b/vendors/flextesa-lib/dune
deleted file mode 100644
index 0f7145cc6f014627a5f3c272c8d9f95d584ceef2..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/dune
+++ /dev/null
@@ -1,20 +0,0 @@
-(library
- (name flextesa)
- (public_name flextesa)
- (flags (:standard -safe-string))
- (libraries
-    fmt
-    cohttp-lwt-unix
-    lwt.unix
-    cmdliner
-    easy-format
-    dum
-    base
-    genspio
-    ezjsonm
-    tezos-stdlib-unix
-    tezos-crypto
-    tezos-base
-    tezos-rpc-http-server
-    ))
-
diff --git a/vendors/flextesa-lib/dune-project b/vendors/flextesa-lib/dune-project
deleted file mode 100644
index 7c895a90de3121f52359f1f0757fe2b646bc2ff3..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/dune-project
+++ /dev/null
@@ -1,2 +0,0 @@
-(lang dune 1.10)
-(name flextesa)
diff --git a/vendors/flextesa-lib/environment_configuration.ml b/vendors/flextesa-lib/environment_configuration.ml
deleted file mode 100644
index fd2cb6d13ef8105941e582cf7936216f0392d7c5..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/environment_configuration.ml
+++ /dev/null
@@ -1,72 +0,0 @@
-open! Internal_pervasives
-
-(** Global configuration from environment variables and such. *)
-
-type 'a var = {name: string; doc: string list; transform: string option -> 'a}
-
-let var name ~doc ~transform = {name; doc; transform}
-
-let var_default name ~doc ~default =
-  var name
-    ~doc:(doc @ [Fmt.str "The default is `%s`." default])
-    ~transform:(Option.value ~default)
-
-type t =
-  { prefix: string
-  ; disabled: bool
-  ; default_cors_origin: string option var
-  ; better_call_dev_base_url: string var
-  ; default_events_level: string option var }
-
-let default () =
-  { prefix= "flextesa_"
-  ; disabled= false
-  ; default_cors_origin=
-      var "node_cors_origin"
-        ~doc:
-          [ "Add CORS headers to all nodes in the sandbox."
-          ; "An empty value means “none.”" ] ~transform:(function
-        | Some "" | None -> None
-        | Some other -> Some other)
-  ; better_call_dev_base_url=
-      var_default "better_call_dev_base_url"
-        ~doc:["Set the base URL for the better-call.dev explorer."]
-        ~default:"https://better-call.dev/sandbox"
-  ; default_events_level=
-      var "default_events_level"
-        ~doc:
-          [ "Set the minimum evenet-level for the event-logging of all \
-             tezos-executables."; "The default is `warning`."
-          ; "The value `none` means: completely disable the event-logging." ]
-        ~transform:(function
-        | None -> Some "warning"
-        | Some "none" -> None
-        | Some s -> Some s) }
-
-type 'a state = < env_config: t ; .. > as 'a
-
-let prefix state = state#env_config.prefix
-let varname pref var = Fmt.str "%s%s" pref var.name
-
-let init state env_config =
-  let reg_var vf =
-    let v = vf env_config in
-    Manpage_builder.State.register_env_variable state
-      (varname env_config.prefix v)
-      v.doc in
-  reg_var (fun e -> e.default_cors_origin) ;
-  reg_var (fun e -> e.better_call_dev_base_url) ;
-  reg_var (fun e -> e.default_events_level)
-
-let get_var_from_environment state varf =
-  let var = varf state#env_config in
-  Caml.Sys.getenv_opt (varname state#env_config.prefix var) |> var.transform
-
-let default_cors_origin state =
-  get_var_from_environment state (fun e -> e.default_cors_origin)
-
-let better_call_dev_base_url state =
-  get_var_from_environment state (fun e -> e.better_call_dev_base_url)
-
-let default_events_level state =
-  get_var_from_environment state (fun e -> e.default_events_level)
diff --git a/vendors/flextesa-lib/experiments.ml b/vendors/flextesa-lib/experiments.ml
deleted file mode 100644
index 925069ac4309754fd7ccba7dac302981cd526883..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/experiments.ml
+++ /dev/null
@@ -1,67 +0,0 @@
-open Internal_pervasives
-
-module Markup_fmt = struct
-  (** An alternative experiment. *)
-
-  let vertical_box ?indent ppf f =
-    let open Fmt in
-    vbox ?indent (fun ppf () -> f ppf) ppf ()
-
-  let wrapping_box ?indent ppf f =
-    let open Fmt in
-    box ?indent (fun ppf () -> f ppf) ppf ()
-
-  type in_par =
-    [`Text of string | `Highlight of in_par | `Concat of in_par list]
-
-  type t =
-    [ `Par of in_par
-    | `Itemize of in_par list
-    | `Raw of string
-    | `Verbatim of string list ]
-
-  let par l : t list =
-    match l with [one] -> [`Par one] | l -> [`Par (`Concat l)]
-
-  let verbatim l = [`Verbatim l]
-  let verbatim_raw raw = [`Verbatim (String.split ~on:'\n' raw)]
-
-  let verbatim_ezjson json =
-    verbatim_raw (Ezjsonm.value_to_string ~minify:false json)
-
-  let t s : in_par list = [`Text s]
-  let tf fmt = Fmt.kstr t fmt
-  let hl l : in_par list = [`Highlight (`Concat l)]
-  let concat l = `Concat l
-  let hlf fmt = Fmt.kstr (fun s -> hl (t s)) fmt
-  let itemize l : t list = [`Itemize (List.map l ~f:(fun l -> `Concat l))]
-
-  let to_fmt (x : t list) ppf () =
-    let open Fmt in
-    let rec pp_in_par ppf = function
-      | `Text s -> text ppf s
-      | `Concat l -> List.iter l ~f:(pp_in_par ppf)
-      | `Highlight s ->
-          Caml.Format.(pp_open_stag ppf (String_tag "prompt")) ;
-          pp_in_par ppf s ;
-          Caml.Format.pp_close_stag ppf () in
-    vertical_box ppf (fun ppf ->
-        list ~sep:cut
-          (fun ppf item ->
-            match item with
-            | `Par in_par -> wrapping_box ppf (fun ppf -> pp_in_par ppf in_par)
-            | `Verbatim sl ->
-                vertical_box ppf (fun ppf ->
-                    string ppf "`````" ;
-                    List.iter sl ~f:(fun l -> cut ppf () ; string ppf l) ;
-                    cut ppf () ;
-                    string ppf "`````")
-            | `Itemize l ->
-                list ~sep:cut
-                  (fun ppf inpar ->
-                    wrapping_box ~indent:2 ppf (fun ppf ->
-                        string ppf "* " ; pp_in_par ppf inpar))
-                  ppf l
-            | `Raw s -> string ppf s)
-          ppf x)
-end
diff --git a/vendors/flextesa-lib/flextesa.opam b/vendors/flextesa-lib/flextesa.opam
deleted file mode 100644
index c124f3b709a87e419665f387e66044cb9e6b795d..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/flextesa.opam
+++ /dev/null
@@ -1,26 +0,0 @@
-opam-version: "2.0"
-version: "dev"
-maintainer: "seb@mondet.org"
-authors: [ "Tezos devteam" ]
-homepage: "https://www.tezos.com/"
-bug-reports: "https://gitlab.com/tezos/tezos/issues"
-dev-repo: "git+https://gitlab.com/tezos/tezos.git"
-license: "MIT"
-depends: [
-  "dune" { >= "1.0.1" }
-  "genspio" { = "0.0.3" }
-  "dum"
-  "tezos-stdlib-unix"
-  "lwt"
-  "fmt"
-  "cohttp-lwt-unix"
-  "tezos-base"
-  "tezos-rpc-http-server"
-]
-build: [
-  ["dune" "build" "-p" name "-j" jobs]
-  ["dune" "runtest" "-p" name "-j" jobs] {with-test}
-]
-synopsis:
-    "Flexible Tezos Sandboxes: library to run various Tezos network-sandboxes"
-
diff --git a/vendors/flextesa-lib/hard_fork.ml b/vendors/flextesa-lib/hard_fork.ml
deleted file mode 100644
index 0c1bbaa61285566814a3a0fa834e54cc3a0c451d..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/hard_fork.ml
+++ /dev/null
@@ -1,43 +0,0 @@
-open Internal_pervasives
-
-type t =
-  { level: int
-  ; protocol_hash: string
-  ; name: string
-  ; baker: Tezos_executable.t
-  ; endorser: Tezos_executable.t
-  ; accuser: Tezos_executable.t }
-
-let cmdliner_term base_state ~docs ?(prefix = "hard-fork") () =
-  let open Cmdliner in
-  let open Cmdliner.Term in
-  let extra_doc = Fmt.str " for the hard-fork (requires --%s)" prefix in
-  pure (fun hard_fork baker endorser accuser ->
-      Option.map hard_fork ~f:(fun (level, protocol_hash) ->
-          {level; name= prefix; protocol_hash; baker; endorser; accuser}))
-  $ Arg.(
-      value
-        (opt
-           (some (pair ~sep:':' int string))
-           None
-           (info [prefix] ~doc:"Make a hard-fork happen" ~docs
-              ~docv:"LEVEL:PROTOCOL-HASH")))
-  $ Tezos_executable.cli_term ~extra_doc base_state `Baker prefix
-  $ Tezos_executable.cli_term ~extra_doc base_state `Endorser prefix
-  $ Tezos_executable.cli_term ~extra_doc base_state `Accuser prefix
-
-let executables {baker; endorser; accuser; _} = [baker; endorser; accuser]
-
-let node_network_config t =
-  let open Ezjsonm in
-  ( "user_activated_upgrades"
-  , list Fn.id
-      [ dict
-          [ ("level", int t.level)
-          ; ("replacement_protocol", string t.protocol_hash) ] ] )
-
-let keyed_daemons t ~client ~key ~lb_vote ~node =
-  [ Tezos_daemon.baker_of_node ~name_tag:t.name ~exec:t.baker ~client node
-      ~key ~lb_vote:(lb_vote t.protocol_hash)
-  ; Tezos_daemon.endorser_of_node ~name_tag:t.name ~exec:t.endorser ~client
-      node ~key ]
diff --git a/vendors/flextesa-lib/hard_fork.mli b/vendors/flextesa-lib/hard_fork.mli
deleted file mode 100644
index 3232d6109be887848cf3efc6e1e6d2f5df6e76e5..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/hard_fork.mli
+++ /dev/null
@@ -1,47 +0,0 @@
-open Internal_pervasives
-
-(** User-activated Upgrades, a.k.a. Hard Forks *)
-
-(**
-
-This module provides helpers to make “hard-fork” protocol changes happen
-in sandboxes.
-    
-See ["src/lib/interactive_mini_network.ml"] for an example of usage.
-
-*)
-
-type t = private
-  { level: int
-  ; protocol_hash: string
-  ; name: string
-  ; baker: Tezos_executable.t
-  ; endorser: Tezos_executable.t
-  ; accuser: Tezos_executable.t }
-
-val cmdliner_term :
-     < manpager: Manpage_builder.State.t ; .. >
-  -> docs:string
-  -> ?prefix:string
-  -> unit
-  -> t option Cmdliner.Term.t
-(** For a given [prefix] (default ["hard-fork"]), provide a family
-    of ["--<prefix>*"] command-line options allowing to configure a
-    user-activated-upgrade. *)
-
-val executables : t -> Tezos_executable.t list
-(** Get all the protocol-specific executable definitions (the “daemons”) involved in
-    this hard-fork. *)
-
-val node_network_config : t -> string * [> Ezjsonm.t]
-(** Generate the JSON field for the ["{ network : { ... } }"] part of a
-    node's configuration file. *)
-
-val keyed_daemons :
-     t
-  -> client:Tezos_client.t
-  -> key:string
-  -> lb_vote:(string -> string option)
-  -> node:Tezos_node.t
-  -> Tezos_daemon.t list
-(** Prepare the baker and endorse daemons to secure the hard-fork. *)
diff --git a/vendors/flextesa-lib/helpers.ml b/vendors/flextesa-lib/helpers.ml
deleted file mode 100644
index 472680397a114224687ec5d32c41ef3b7f011d13..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/helpers.ml
+++ /dev/null
@@ -1,322 +0,0 @@
-open Internal_pervasives
-open Console
-
-let dump_connection =
-  let open EF in
-  let open Tezos_node in
-  function
-  | `Duplex (na, nb) ->
-      af "%s:%d <-> %s:%d" na.id na.p2p_port nb.id nb.p2p_port
-  | `From_to (na, nb) ->
-      haf "%s:%d --> %s:%d" na.id na.p2p_port nb.id nb.p2p_port
-  | `Missing (na, int) ->
-      ksprintf shout "%s:%d --> ???:%d" na.id na.p2p_port int
-
-let dump_connections state nodes =
-  let conns = Tezos_node.connections nodes in
-  say state
-    (let open EF in
-    desc_list (haf "Connections:") (List.map conns ~f:dump_connection))
-
-let clear_root state =
-  let root = Paths.(root state) in
-  System_error.catch
-    (fun () -> ksprintf Lwt_unix.system "rm -fr %s" (Caml.Filename.quote root))
-    ()
-  >>= function
-  | Unix.WEXITED 0 -> return ()
-  | _ -> System_error.fail_fatalf "cannot delete root path (%S)" root
-
-let wait_for ?(attempts_factor = 0.) state ~attempts ~seconds f =
-  let rec attempt nth =
-    let again () = attempt (nth + 1) in
-    f nth
-    >>= function
-    | `Done x -> return x
-    | `Not_done msg when nth < attempts ->
-        let sleep_time = Float.((attempts_factor * of_int nth) + seconds) in
-        say state
-          EF.(
-            wf "%s: attempt %d/%d, sleeping %.02f seconds" msg nth attempts
-              sleep_time)
-        >>= fun () -> System.sleep sleep_time >>= fun () -> again ()
-    | `Not_done msg -> fail (`Waiting_for (msg, `Time_out)) in
-  attempt 1
-
-let kill_node state nod =
-  Running_processes.find_process_by_id ~only_running:true state
-    ~f:(String.( = ) nod.Tezos_node.id)
-  >>= fun states ->
-  ( match states with
-  | [one] -> return one
-  | _ ->
-      System_error.fail_fatalf "Expecting one state for node %s"
-        nod.Tezos_node.id )
-  >>= fun node_state_0 -> Running_processes.kill state node_state_0
-
-let restart_node ~client_exec state nod =
-  Running_processes.start state (Tezos_node.process state nod)
-  >>= fun _ ->
-  let client = Tezos_client.of_node nod ~exec:client_exec in
-  say state
-    EF.(wf "Started node %s, waiting for bootstrap …" nod.Tezos_node.id)
-  >>= fun () -> Tezos_client.wait_for_node_bootstrap state client
-
-module Counter_log = struct
-  type t = (string * int) list ref
-
-  let create () = ref []
-  let add t s n = t := (s, n) :: !t
-  let incr t s = add t s 1
-  let sum t = List.fold !t ~init:0 ~f:(fun prev (_, s) -> prev + s)
-
-  let to_table_string t =
-    let total = "**Total:**" in
-    let longest =
-      List.fold !t ~init:total ~f:(fun p (n, _) ->
-          if String.length p < String.length n then n else p) in
-    List.rev_map
-      ((total, sum t) :: !t)
-      ~f:(fun (cmt, n) ->
-        sprintf "| %s %s|% 8d|" cmt
-          (String.make (String.length longest - String.length cmt + 2) '.')
-          n)
-    |> String.concat ~sep:"\n"
-end
-
-module Netstat = struct
-  let check_version state =
-    Running_processes.run_cmdf state "netstat --version"
-    >>= fun version_res ->
-    match version_res#status with
-    | Unix.WEXITED 0 ->
-        (* This is a linux-ish netstat: *)
-        return `Fine
-    | _ -> return `Not_right
-
-  let netstat_dash_nut state =
-    check_version state
-    >>= function
-    | `Fine ->
-        Running_processes.run_cmdf state "netstat -nut"
-        >>= fun res ->
-        Process_result.Error.fail_if_non_zero res "netstat -nut command"
-        >>= fun () ->
-        let rows =
-          List.filter_mapi res#out ~f:(fun idx line ->
-              match
-                String.split line ~on:' '
-                |> List.filter_map ~f:(fun s ->
-                       match String.strip s with "" -> None | s -> Some s)
-              with
-              | ("tcp" | "tcp6") :: _ as row -> Some (`Tcp (idx, row))
-              | _ -> Some (`Wrong (idx, line))) in
-        return rows
-    | `Not_right ->
-        Console.say state
-          EF.(
-            desc (shout "Warning:")
-              (wf
-                 "This does not look like a linux-netstat; port-availability \
-                  checks are hence disabled."))
-        >>= fun () -> return []
-
-  let all_listening_ports rows =
-    List.filter_map rows ~f:(function
-      | `Tcp (_, _ :: _ :: _ :: addr :: _) as row -> (
-        match String.split addr ~on:':' with
-        | [_; port] -> ( try Some (Int.of_string port, row) with _ -> None )
-        | _ -> None )
-      | _ -> None)
-
-  let used_listening_ports state =
-    netstat_dash_nut state
-    >>= fun rows ->
-    let all_used = all_listening_ports rows in
-    return all_used
-end
-
-module System_dependencies = struct
-  module Error = struct
-    type t = [`Precheck_failure of string]
-
-    let pp fmt (`Precheck_failure f) =
-      Caml.Format.fprintf fmt "Failed precheck: %S" f
-
-    let failf fmt =
-      Caml.Format.kasprintf (fun s -> fail (`Precheck_failure s)) fmt
-  end
-
-  open Error
-
-  let precheck ?(using_docker = false) ?(protocol_paths = [])
-      ?(executables : Tezos_executable.t list = []) state how_to_react =
-    let commands_to_check =
-      (if using_docker then ["docker"] else [])
-      @ ["setsid"; "curl"; "netstat"]
-      @ List.map executables ~f:Tezos_executable.get in
-    List.fold ~init:(return []) commands_to_check ~f:(fun prev_m cmd ->
-        prev_m
-        >>= fun prev ->
-        Running_processes.run_cmdf state "type %s" (Caml.Filename.quote cmd)
-        >>= fun result ->
-        match result#status with
-        | Unix.WEXITED 0 -> return prev
-        | _ -> return (`Missing_exec (cmd, result) :: prev))
-    >>= fun errors_or_warnings ->
-    Netstat.check_version state
-    >>= (function
-          | `Fine -> return errors_or_warnings
-          | `Not_right -> return (`Wrong_netstat :: errors_or_warnings))
-    >>= fun errors_or_warnings ->
-    List.fold protocol_paths ~init:(return errors_or_warnings)
-      ~f:(fun prev_m path ->
-        prev_m
-        >>= fun prev ->
-        System_error.catch Lwt_unix.file_exists (path // "TEZOS_PROTOCOL")
-        >>= function
-        | true -> return prev
-        | false -> return (`Not_a_protocol_path path :: prev))
-    >>= fun errors_or_warnings ->
-    match (errors_or_warnings, how_to_react) with
-    | [], _ -> return ()
-    | more, `Or_fail -> (
-        let is_not_just_a_warning = function
-          | `Wrong_netstat | `Missing_exec ("netstat", _) -> false
-          | `Missing_exec _ | `Not_a_protocol_path _ -> true in
-        Console.sayf state
-          Fmt.(
-            fun ppf () ->
-              vbox ~indent:2
-                (fun ppf () ->
-                  string ppf "System dependencies failed precheck:" ;
-                  List.iter more ~f:(fun item ->
-                      cut ppf () ;
-                      box ~indent:2
-                        (fun ppf () ->
-                          pf ppf "* %s "
-                            ( if is_not_just_a_warning item then "Fatal-error:"
-                            else "Warning:" ) ;
-                          match item with
-                          | `Missing_exec (path, _) ->
-                              (* pp_open_hovbox ppf 0 ; *)
-                              kstr (text ppf) "Missing executable `%s`." path
-                          | `Wrong_netstat -> text ppf "Wrong netstat version."
-                          | `Not_a_protocol_path path ->
-                              kstr (text ppf) "`%s` is not a protocol." path)
-                        ppf ()))
-                ppf ())
-        >>= fun () ->
-        ( if
-          List.exists more ~f:(function
-            | `Wrong_netstat | `Missing_exec ("setsid", _) -> true
-            | _ -> false)
-        then
-          Console.say state
-            EF.(
-              desc (shout "Warning:")
-                (wf
-                   "This does not look like a standard Linux-ish environment. \
-                    If you are on MacOSX, see \
-                    https://gitlab.com/tezos/flextesa/blob/master/README.md#macosx-users "))
-        else return () )
-        >>= fun () ->
-        ( if
-          List.exists more ~f:(function
-            | `Missing_exec ("tezos-node", _)
-              when Caml.Sys.file_exists ("." // "tezos-node") ->
-                true
-            | _ -> false)
-        then
-          Console.say state
-            EF.(
-              desc (prompt "Tip:")
-                (wf
-                   "The `tezos-node` executable is missing but there seems to \
-                    be one in the current directory, maybe you can pass \
-                    `./tezos-node` with the right option (see `--help`) or \
-                    simply add `export PATH=.:$PATH` to allow unix tools to \
-                    find it."))
-        else return () )
-        >>= fun () ->
-        let non_warning_errors = List.filter more ~f:is_not_just_a_warning in
-        match non_warning_errors with
-        | [] ->
-            Console.say state
-              EF.(
-                wf "Pre-check noticed only %d warnings, no errors"
-                  (List.length more))
-        | _ ->
-            failf "%d errors were raised during precheck."
-              (List.length non_warning_errors) )
-end
-
-module Shell_environment = struct
-  type t = {aliases: (string * string * string) list}
-
-  let make ~aliases = {aliases}
-
-  let build state ~clients =
-    let aliases =
-      List.concat_mapi clients ~f:(fun i c ->
-          let call =
-            List.map ~f:Caml.Filename.quote
-              (Tezos_client.client_call state c []) in
-          let cmd exec = String.concat ~sep:" " (exec :: call) in
-          let extra =
-            let help = "Call the tezos-client used by the sandbox." in
-            match Tezos_executable.get c.Tezos_client.exec with
-            | "tezos-client" -> []
-            | f when Caml.Filename.is_relative f ->
-                [(sprintf "c%d" i, cmd (Caml.Sys.getcwd () // f), help)]
-            | f -> [(sprintf "c%d" i, cmd (Caml.Sys.getcwd () // f), help)]
-          in
-          [ ( sprintf "tc%d" i
-            , cmd "tezos-client"
-            , "Call the `tezos-client` from the path." ) ]
-          @ extra) in
-    make ~aliases
-
-  let write state {aliases} ~path =
-    let content =
-      String.concat ~sep:"\n"
-        ( ["# Shell-environment generated by a flextesa-sandbox"]
-        @ List.concat_map aliases ~f:(fun (k, v, doc) ->
-              [ sprintf "echo %s"
-                  (sprintf "Defining alias %s: %s" k doc |> Caml.Filename.quote)
-              ; sprintf "alias %s=%s" k (Caml.Filename.quote v) ]) ) in
-    System.write_file state path ~content
-
-  let help_command state t ~path =
-    Console.Prompt.unit_and_loop
-      ~description:"Show help about the shell-environment." ["help-env"]
-      (fun _sexps ->
-        Console.sayf state
-          More_fmt.(
-            fun ppf () ->
-              let pick_and_alias ppf () =
-                let k, _, _ = List.random_element_exn t.aliases in
-                string ppf k in
-              vertical_box ~indent:2 ppf (fun ppf ->
-                  tag "prompt" ppf (fun ppf -> wf ppf "Shell Environment") ;
-                  cut ppf () ;
-                  wf ppf "* A loadable shell environment is available at `%s`."
-                    path ;
-                  cut ppf () ;
-                  wf ppf
-                    "* It contains %d POSIX-shell aliases (compatible with \
-                     `bash`, etc.)."
-                    (List.length t.aliases) ;
-                  cut ppf () ;
-                  cut ppf () ;
-                  wf ppf "Example:" ;
-                  cut ppf () ;
-                  cut ppf () ;
-                  pf ppf "    . %s" path ;
-                  cut ppf () ;
-                  pf ppf "    %a list known addresses" pick_and_alias () ;
-                  cut ppf () ;
-                  pf ppf "    %a rpc get /chains/main/blocks/head/metadata"
-                    pick_and_alias () ;
-                  cut ppf ())))
-end
diff --git a/vendors/flextesa-lib/helpers.mli b/vendors/flextesa-lib/helpers.mli
deleted file mode 100644
index d03c2467ae255f7929135e7b21b2adad2e382bdb..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/helpers.mli
+++ /dev/null
@@ -1,115 +0,0 @@
-(** Generic testing helpers *)
-
-open Internal_pervasives
-
-val dump_connections :
-     < application_name: string ; console: Console.t ; .. >
-  -> Tezos_node.t list
-  -> (unit, [> System_error.t]) Asynchronous_result.t
-(** Display all the P2P connections of a set of nodes, see
-    {!Tezos_node.connections}. *)
-
-val clear_root :
-  < paths: Paths.t ; .. > -> (unit, [> System_error.t]) Asynchronous_result.t
-(** Remove (["rm -fr .."]) the root-path of the current [state]. *)
-
-val wait_for :
-     ?attempts_factor:float
-  -> < application_name: string ; console: Console.t ; .. >
-  -> attempts:int
-  -> seconds:float
-  -> (   int
-      -> ( [`Done of 'a | `Not_done of string]
-         , ([> System_error.t | `Waiting_for of string * [`Time_out]]
-            as
-            'errors) )
-         Asynchronous_result.t)
-  -> ('a, 'errors) Asynchronous_result.t
-(** Try to wait for an event. The pause between attempts is
-    [(attempts_factor * attempts) + seconds] where the default
-    [attempts_factor] is [0.]. *)
-
-val kill_node :
-     < runner: Running_processes.State.t ; .. >
-  -> Tezos_node.t
-  -> (unit, [> System_error.t]) Asynchronous_result.t
-(** Kill a node's process. *)
-
-val restart_node :
-     client_exec:Tezos_executable.t
-  -> < application_name: string
-     ; console: Console.t
-     ; env_config: Environment_configuration.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> Tezos_node.t
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-(** Restart a killed node. *)
-
-(** Stateful “message × count” log, see its use in, e.g.,
-    ["./src/bin_flextesa/command_voting.ml"] where baked-levels
-    are accumulated and then displayed. . *)
-module Counter_log : sig
-  type t
-
-  val create : unit -> t
-  val add : t -> string -> int -> unit
-  val incr : t -> string -> unit
-  val sum : t -> int
-  val to_table_string : t -> string
-end
-
-module Netstat : sig
-  val used_listening_ports :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> ( (int * [> `Tcp of int * string list]) list
-       , [> System_error.t | Process_result.Error.t] )
-       Asynchronous_result.t
-  (** Call ["netstat"] to find TCP ports already in use. *)
-end
-
-module System_dependencies : sig
-  module Error : sig
-    type t = [`Precheck_failure of string]
-
-    val pp : Caml.Format.formatter -> [< `Precheck_failure of string] -> unit
-  end
-
-  val precheck :
-       ?using_docker:bool
-    -> ?protocol_paths:string list
-    -> ?executables:Tezos_executable.t list
-    -> < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> [< `Or_fail]
-    -> (unit, [> System_error.t | Error.t]) Asynchronous_result.t
-end
-
-module Shell_environment : sig
-  type t
-
-  val make : aliases:(string * string * string) list -> t
-  (** Aliases are [(name, command, doc)] tuples. *)
-
-  val build : < paths: Paths.t ; .. > -> clients:Tezos_client.t list -> t
-
-  val write :
-       < application_name: string ; .. >
-    -> t
-    -> path:string
-    -> (unit, [> System_error.t]) Attached_result.t Lwt.t
-
-  val help_command :
-       < application_name: string ; console: Console.t ; .. >
-    -> t
-    -> path:string
-    -> Console.Prompt.item
-end
diff --git a/vendors/flextesa-lib/interactive_mini_network.ml b/vendors/flextesa-lib/interactive_mini_network.ml
deleted file mode 100644
index 4fccb95a960a281ce0ab55efc9219592dc347ec0..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/interactive_mini_network.ml
+++ /dev/null
@@ -1,411 +0,0 @@
-open Internal_pervasives
-open Console
-
-(** A.k.a the [chain_id] *)
-module Genesis_block_hash = struct
-  let path state = Paths.root state // "genesis.json"
-
-  let to_json _state genesis =
-    Ezjsonm.dict [("genesis-block-hash", `String genesis)]
-
-  (** See implementation of {!Tezos_node}, this corresponds to the Chain-id
-      ["NetXKMbjQL2SBox"] *)
-  let default = "BLdZYwNF8Rn6zrTWkuRRNyrj6bQWPkfBog2YKhWhn5z3ApmpzBf"
-
-  module Choice = struct
-    type t = [`Random | `Force of string | `Default]
-
-    let pp : t Fmt.t =
-     fun ppf ->
-      let open Fmt in
-      function
-      | `Random -> pf ppf "Random"
-      | `Default -> pf ppf "Default:%s" default
-      | `Force v -> pf ppf "Forced:%s" v
-
-    let pp_short : t Fmt.t =
-     fun ppf ->
-      let open Fmt in
-      function
-      | `Random -> pf ppf "Random"
-      | `Default -> pf ppf "Default"
-      | `Force _ -> pf ppf "Forced"
-
-    let cmdliner_term () : t Cmdliner.Term.t =
-      let open Cmdliner in
-      let open Term in
-      ret
-        ( pure (function
-            | None | Some "default" -> `Ok `Default
-            | Some "random" -> `Ok `Random
-            | Some force -> `Ok (`Force force) )
-        $ Arg.(
-            let doc =
-              Fmt.str
-                "Set the genesis block hash (from which the chain-id is \
-                 derived). The default (or the string %S) is `%s...`, %S means \
-                 pick-one-at-random. This option is ignored when the \
-                 `--keep-root` option allows the chain to resume (the \
-                 previously chosen genesis-hash will be still in effect)."
-                "default"
-                (String.sub default ~pos:0 ~len:8)
-                "random" in
-            value
-              (opt (some string) None
-                 (info ["genesis-block-hash"] ~docv:"BLOCK-HASH|random|default"
-                    ~doc ) )) )
-  end
-
-  let chain_id_of_hash hash =
-    let open Tezos_crypto in
-    Option.map (Block_hash.of_b58check_opt hash) ~f:(fun bh ->
-        bh |> Chain_id.of_block_hash |> Chain_id.to_b58check )
-
-  let process_choice state choice =
-    let json_file = path state in
-    let pp_hash_fancily ppf h =
-      let open More_fmt in
-      pf ppf "`%s` (corresponding chain-id: `%s`)" h
-        (chain_id_of_hash h |> Option.value ~default:"ERROR-WRONG-HASH") in
-    match Caml.Sys.file_exists json_file with
-    | true ->
-        System.read_file state json_file
-        >>= fun json_str ->
-        System_error.catch_exn
-          ~attach:[("json-content", `Verbatim [json_str])]
-          (fun () ->
-            match Ezjsonm.value_from_string json_str with
-            | `O [("genesis-block-hash", `String hash)] -> hash
-            | _ ->
-                Fmt.failwith "invalid json for genesis-block-hash: %S" json_str
-            )
-        >>= fun hash ->
-        Console.sayf state
-          More_fmt.(
-            fun ppf () ->
-              wf ppf "Genesis-block-hash already set: %a%a" pp_hash_fancily hash
-                (fun ppf -> function
-                  | `Default -> pf ppf "."
-                  | choice ->
-                      pf ppf " (user choice “%a” is then ignored)."
-                        Choice.pp choice )
-                choice)
-        >>= fun () -> return hash
-    | false ->
-        let hash =
-          match choice with
-          | `Default -> default
-          | `Force v -> v
-          | `Random ->
-              let seed =
-                Fmt.str "%d:%f" (Random.int 1_000_000) (Unix.gettimeofday ())
-              in
-              let open Tezos_crypto in
-              let block_hash = Block_hash.hash_string [seed] in
-              Block_hash.to_b58check block_hash in
-        Console.sayf state
-          More_fmt.(
-            fun ppf () ->
-              wf ppf
-                "Genesis-block-hash not set, using: %a (from user choice: \
-                 “%a”)."
-                pp_hash_fancily hash Choice.pp_short choice)
-        >>= fun () ->
-        Running_processes.run_successful_cmdf state "mkdir -p %s"
-          Caml.Filename.(dirname json_file |> quote)
-        >>= fun _ ->
-        System.write_file state json_file
-          ~content:(to_json state hash |> Ezjsonm.value_to_string)
-        >>= fun () -> return hash
-end
-
-let run state ~protocol ~size ~base_port ~clear_root ~no_daemons_for ?hard_fork
-    ~genesis_block_choice ?external_peer_ports ~nodes_history_mode_edits
-    ~with_baking ?generate_kiln_config node_exec client_exec baker_exec
-    endorser_exec accuser_exec test_kind () =
-  ( if clear_root then
-    Console.say state EF.(wf "Clearing root: `%s`" (Paths.root state))
-    >>= fun () -> Helpers.clear_root state
-  else Console.say state EF.(wf "Keeping root: `%s`" (Paths.root state)) )
-  >>= fun () ->
-  Genesis_block_hash.process_choice state genesis_block_choice
-  >>= fun genesis_block_hash ->
-  Helpers.System_dependencies.precheck state `Or_fail
-    ~executables:
-      ( [node_exec; client_exec]
-      @ (if with_baking then [baker_exec; endorser_exec; accuser_exec] else [])
-      @ Option.value_map hard_fork ~default:[] ~f:Hard_fork.executables )
-  >>= fun () ->
-  Console.say state EF.(wf "Starting up the network.")
-  >>= fun () ->
-  let node_custom_network =
-    let base =
-      Tezos_node.Config_file.network ~genesis_hash:genesis_block_hash () in
-    `Json
-      (Ezjsonm.dict
-         ( base
-         @ Option.value_map ~default:[] hard_fork ~f:(fun hf ->
-               [Hard_fork.node_network_config hf] ) ) ) in
-  Test_scenario.network_with_protocol ?external_peer_ports ~protocol ~size
-    ~do_activation:clear_root ~nodes_history_mode_edits ~base_port state
-    ~node_exec ~client_exec ~node_custom_network
-  >>= fun (nodes, protocol) ->
-  Console.say state EF.(wf "Network started, preparing scenario.")
-  >>= fun () ->
-  Tezos_client.rpc state
-    ~client:(Tezos_client.of_node (List.hd_exn nodes) ~exec:client_exec)
-    `Get ~path:"/chains/main/chain_id"
-  >>= fun chain_id_json ->
-  let network_id =
-    match chain_id_json with `String s -> s | _ -> assert false in
-  Asynchronous_result.map_option generate_kiln_config ~f:(fun kiln_config ->
-      Kiln.Configuration_directory.generate state kiln_config
-        ~peers:(List.map nodes ~f:(fun {Tezos_node.p2p_port; _} -> p2p_port))
-        ~sandbox_json:(Tezos_protocol.sandbox_path state protocol)
-        ~nodes:
-          (List.map nodes ~f:(fun {Tezos_node.rpc_port; _} ->
-               sprintf "http://localhost:%d" rpc_port ) )
-        ~bakers:
-          (List.map protocol.Tezos_protocol.bootstrap_accounts
-             ~f:(fun (account, _) ->
-               Tezos_protocol.Account.(name account, pubkey_hash account) ) )
-        ~network_string:network_id ~node_exec ~client_exec
-        ~protocol_execs:
-          [(protocol.Tezos_protocol.hash, baker_exec, endorser_exec)] )
-  >>= fun (_ : unit option) ->
-  let to_keyed acc client =
-    let key, priv = Tezos_protocol.Account.(name acc, private_key acc) in
-    let keyed_client =
-      Tezos_client.Keyed.make client ~key_name:key ~secret_key:priv in
-    keyed_client in
-  let lb_vote = match protocol.kind with `Alpha -> Some "pass" | _ -> None in
-  let hard_fork_lb_vote = function
-    | "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK" -> Some "pass"
-    | _ -> None
-  in
-  let keys_and_daemons =
-    let pick_a_node_and_client idx =
-      match List.nth nodes (Int.rem (1 + idx) (List.length nodes)) with
-      | Some node -> (node, Tezos_client.of_node node ~exec:client_exec)
-      | None -> assert false in
-    Tezos_protocol.bootstrap_accounts protocol
-    |> List.filter_mapi ~f:(fun idx acc ->
-           let node, client = pick_a_node_and_client idx in
-           let key = Tezos_protocol.Account.name acc in
-           if List.mem ~equal:String.equal no_daemons_for key then None
-           else
-             Some
-               ( acc
-               , client
-               , to_keyed acc client
-               , Option.value_map hard_fork ~default:[]
-                   ~f:(Hard_fork.keyed_daemons ~client ~node ~key
-                         ~lb_vote:hard_fork_lb_vote)
-                 @ [ Tezos_daemon.baker_of_node ~exec:baker_exec ~client node
-                       ~key ~lb_vote
-                   ; Tezos_daemon.endorser_of_node ~exec:endorser_exec ~client
-                       node ~key ] ) ) in
-  List_sequential.iter keys_and_daemons ~f:(fun (_, _, kc, _) ->
-      Tezos_client.Keyed.initialize state kc >>= fun _ -> return () )
-  >>= fun () ->
-  Interactive_test.Pauser.add_commands state
-    Interactive_test.Commands.
-      [ generate_traffic_command state
-          ~clients:(List.map keys_and_daemons ~f:(fun (_, _, kc, _) -> kc)) ] ;
-  ( if with_baking then
-    let accusers =
-      List.map nodes ~f:(fun node ->
-          let client = Tezos_client.of_node node ~exec:client_exec in
-          Tezos_daemon.accuser_of_node ~exec:accuser_exec ~client node ) in
-    List_sequential.iter accusers ~f:(fun acc ->
-        Running_processes.start state (Tezos_daemon.process state acc)
-        >>= fun {process= _; lwt= _} -> return () )
-    >>= fun () ->
-    List_sequential.iter keys_and_daemons ~f:(fun (_acc, client, kc, daemons) ->
-        Tezos_client.wait_for_node_bootstrap state client
-        >>= fun () ->
-        let key_name = kc.Tezos_client.Keyed.key_name in
-        say state
-          EF.(
-            desc_list
-              (haf "Registration-as-delegate:")
-              [ desc (af "Client:") (af "%S" client.Tezos_client.id)
-              ; desc (af "Key:") (af "%S" key_name) ])
-        >>= fun () ->
-        Tezos_client.register_as_delegate state client ~key_name
-        >>= fun () ->
-        say state
-          EF.(
-            desc_list (haf "Starting daemons:")
-              [ desc (af "Client:") (af "%S" client.Tezos_client.id)
-              ; desc (af "Key:") (af "%S" key_name) ])
-        >>= fun () ->
-        List_sequential.iter daemons ~f:(fun daemon ->
-            Running_processes.start state (Tezos_daemon.process state daemon)
-            >>= fun {process= _; lwt= _} -> return () ) )
-  else
-    List.fold ~init:(return []) keys_and_daemons
-      ~f:(fun prev_m (_acc, client, keyed, _) ->
-        prev_m
-        >>= fun prev ->
-        Tezos_client.wait_for_node_bootstrap state client
-        >>= fun () -> return (keyed :: prev) )
-    >>= fun clients ->
-    Interactive_test.Pauser.add_commands state
-      Interactive_test.Commands.[bake_command state ~clients] ;
-    return () )
-  >>= fun () ->
-  let clients = List.map keys_and_daemons ~f:(fun (_, c, _, _) -> c) in
-  Helpers.Shell_environment.(
-    let path = Paths.root state // "shell.env" in
-    let env = build state ~clients in
-    write state env ~path >>= fun () -> return (help_command state env ~path))
-  >>= fun shell_env_help ->
-  Interactive_test.Pauser.add_commands state
-    Interactive_test.Commands.(
-      shell_env_help :: all_defaults state ~nodes
-      @ [secret_keys state ~protocol]
-      @ arbitrary_commands_for_each_and_all_clients state ~clients) ;
-  match test_kind with
-  | `Interactive ->
-      Interactive_test.Pauser.generic ~force:true state
-        EF.[haf "Sandbox is READY \\o/"]
-  | `Random_traffic (`Any, `Until level) ->
-      System.sleep 10.
-      >>= fun () ->
-      Traffic_generation.Random.run state ~protocol ~nodes ~clients
-        ~until_level:level `Any
-  | `Wait_level (`At_least lvl as opt) ->
-      let seconds =
-        let multiplier = 10 in
-        let tbb =
-          protocol.Tezos_protocol.time_between_blocks |> List.hd
-          |> Option.value ~default:10 in
-        Float.of_int (tbb * multiplier) in
-      let attempts = 2 * lvl in
-      Test_scenario.Queries.wait_for_all_levels_to_be state ~attempts ~seconds
-        nodes opt
-
-let cmd () =
-  let open Cmdliner in
-  let open Term in
-  let pp_error = Test_command_line.Common_errors.pp in
-  let base_state =
-    Test_command_line.Command_making_state.make ~application_name:"Flextesa"
-      ~command_name:"mininet" () in
-  let docs = Manpage_builder.section_test_scenario base_state in
-  let term =
-    pure
-      (fun
-        test_kind
-        (`Clear_root clear_root)
-        size
-        base_port
-        (`External_peers external_peer_ports)
-        (`No_daemons_for no_daemons_for)
-        (`With_baking with_baking)
-        protocol
-        bnod
-        bcli
-        bak
-        endo
-        accu
-        hard_fork
-        genesis_block_choice
-        generate_kiln_config
-        nodes_history_mode_edits
-        state
-      ->
-        let actual_test =
-          run state ~size ~base_port ~protocol bnod bcli bak endo accu
-            ?hard_fork ~clear_root ~nodes_history_mode_edits ~with_baking
-            ?generate_kiln_config ~external_peer_ports ~no_daemons_for
-            ~genesis_block_choice test_kind in
-        Test_command_line.Run_command.or_hard_fail state ~pp_error
-          (Interactive_test.Pauser.run_test ~pp_error state actual_test) )
-    $ term_result ~usage:true
-        Arg.(
-          pure
-            Result.(
-              fun level_opt random_traffic ->
-                match (level_opt, random_traffic) with
-                | Some l, None -> return (`Wait_level (`At_least l))
-                | None, None -> return `Interactive
-                | Some l, Some kind -> return (`Random_traffic (kind, `Until l))
-                | None, Some _ ->
-                    fail
-                      (`Msg
-                        "Error: option `--random-traffic` requires also \
-                         `--until-level`." ))
-          $ value
-              (opt (some int) None
-                 (info ["until-level"] ~docs
-                    ~doc:"Run the sandbox until a given level (not interactive)" ) )
-          $ value
-              (opt
-                 (some (enum [("any", `Any)]))
-                 None
-                 (info ["random-traffic"] ~docs
-                    ~doc:"Generate random traffic (requires `--until-level`)." ) ))
-    $ Arg.(
-        pure (fun kr -> `Clear_root (not kr))
-        $ value
-            (flag
-               (info ["keep-root"] ~docs
-                  ~doc:
-                    "Do not erase the root path before starting (this also \
-                     makes the sandbox start-up bypass the protocol-activation \
-                     step)." ) ))
-    $ Arg.(
-        value & opt int 5
-        & info ["size"; "S"] ~docs ~doc:"Set the size of the network.")
-    $ Arg.(
-        value & opt int 20_000
-        & info ["base-port"; "P"] ~docs ~doc:"Base port number to build upon.")
-    $ Arg.(
-        pure (fun l -> `External_peers l)
-        $ value
-            (opt_all int []
-               (info ["add-external-peer-port"] ~docv:"PORT-NUMBER" ~docs
-                  ~doc:"Add $(docv) to the peers of the network nodes." ) ))
-    $ Arg.(
-        pure (fun l -> `No_daemons_for l)
-        $ value
-            (opt_all string []
-               (info ["no-daemons-for"] ~docv:"ACCOUNT-NAME" ~docs
-                  ~doc:"Do not start daemons for $(docv)." ) ))
-    $ Arg.(
-        pure (fun x -> `With_baking (not x))
-        $ value
-            (flag
-               (info ["no-baking"] ~docs
-                  ~doc:
-                    "Completely disable baking/endorsing/accusing (you need to \
-                     bake manually to make the chain advance)." ) ))
-    $ Tezos_protocol.cli_term base_state
-    $ Tezos_executable.cli_term base_state `Node "tezos"
-    $ Tezos_executable.cli_term base_state `Client "tezos"
-    $ Tezos_executable.cli_term base_state `Baker "tezos"
-    $ Tezos_executable.cli_term base_state `Endorser "tezos"
-    $ Tezos_executable.cli_term base_state `Accuser "tezos"
-    $ Hard_fork.cmdliner_term ~docs base_state ()
-    $ Genesis_block_hash.Choice.cmdliner_term ()
-    $ Kiln.Configuration_directory.cli_term base_state
-    $ Tezos_node.History_modes.cmdliner_term base_state
-    $ Test_command_line.Full_default_state.cmdliner_term base_state () in
-  let info =
-    let doc = "Small network sandbox with bakers, endorsers, and accusers." in
-    let man : Manpage.block list =
-      Manpage_builder.make base_state
-        ~intro_blob:
-          "This test builds a small sandbox network, start various daemons, \
-           and then gives the user an interactive command prompt to inspect \
-           the network."
-        [ `P
-            "One can also run this sandbox with `--no-baking` to make baking \
-             interactive-only."
-        ; `P
-            "There is also the option of running the sandbox non-interactively \
-             for a given number of blocks, cf. `--until-level LEVEL`." ] in
-    Cmd.info "mini-network" ~man ~doc in
-  Cmd.v info term
diff --git a/vendors/flextesa-lib/interactive_test.ml b/vendors/flextesa-lib/interactive_test.ml
deleted file mode 100644
index a8745ea3f164267dd991c40b63ecba915369a1eb..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/interactive_test.ml
+++ /dev/null
@@ -1,856 +0,0 @@
-open Internal_pervasives
-
-module Commands = struct
-  let cmdline_fail fmt = Fmt.kstr (fun s -> fail (`Command_line s)) fmt
-
-  let no_args = function
-    | [] -> return ()
-    | _more -> cmdline_fail "this command expects no arguments"
-
-  let flag f sexps = List.mem sexps (Base.Sexp.Atom f) ~equal:Base.Sexp.equal
-
-  let unit_loop_no_args ~description opts f =
-    Console.Prompt.unit_and_loop ~description opts (fun sexps ->
-        no_args sexps >>= fun () -> f ())
-
-  module Sexp_options = struct
-    type option = {name: string; placeholders: string list; description: string}
-
-    let make_option name ?(placeholders = []) description =
-      {name; placeholders; description}
-
-    let pp_options l ppf () =
-      let open More_fmt in
-      vertical_box ~indent:2 ppf (fun ppf ->
-          pf ppf "Options:" ;
-          List.iter l ~f:(fun {name; placeholders; description} ->
-              cut ppf () ;
-              wrapping_box ~indent:2 ppf (fun ppf ->
-                  let opt_ex ppf () =
-                    prompt ppf (fun ppf ->
-                        pf ppf "(%s%s)" name
-                          ( if Poly.equal placeholders [] then ""
-                          else
-                            List.map ~f:(str " %s") placeholders
-                            |> String.concat ~sep:"" )) in
-                  pf ppf "* %a: %a" opt_ex () text description)))
-
-    let find opt sexps f =
-      List.find_map sexps
-        ~f:
-          Sexp.(
-            function
-            | List (Atom a :: more)
-              when String.equal a opt.name
-                   && Int.(List.length more = List.length opt.placeholders) ->
-                Some (f more)
-            | _ -> None)
-
-    let get opt sexps ~default ~f =
-      match find opt sexps f with
-      | Some n -> return n
-      | None -> default ()
-      | exception e -> cmdline_fail "Getting option %s: %a" opt.name Exn.pp e
-
-    let get_int_exn = function
-      | Sexp.[Atom a] -> (
-        try Int.of_string a with _ -> Fmt.failwith "%S is not an integer" a )
-      | other -> Fmt.failwith "wrong structure: %a" Sexp.pp (Sexp.List other)
-
-    let get_float_exn = function
-      | Sexp.[Atom a] -> (
-        try Float.of_string a with _ -> Fmt.failwith "%S is not a float" a )
-      | other -> Fmt.failwith "wrong structure: %a" Sexp.pp (Sexp.List other)
-
-    let port_number_doc _ ~default_port =
-      make_option "port" ~placeholders:["<int>"]
-        Fmt.(str "Use port number <int> instead of %d (default)." default_port)
-
-    let port_number _state ~default_port sexps =
-      match
-        List.find_map sexps
-          ~f:
-            Base.Sexp.(
-              function
-              | List [Atom "port"; Atom p] -> (
-                try Some (`Ok (Int.of_string p))
-                with _ -> Some (`Not_an_int p) )
-              | List (Atom "port" :: _ as other) -> Some (`Wrong_option other)
-              | _other -> None)
-      with
-      | None -> return default_port
-      | Some (`Ok p) -> return p
-      | Some ((`Not_an_int _ | `Wrong_option _) as other) ->
-          let problem =
-            match other with
-            | `Not_an_int s -> Fmt.str "This is not an integer: %S." s
-            | `Wrong_option s ->
-                Fmt.str "Usage is (port <int>), too many arguments here: %s."
-                  Base.Sexp.(to_string_hum (List s)) in
-          fail (`Command_line "Error parsing (port ...) option")
-            ~attach:[("Problem", `Text problem)]
-  end
-
-  let du_sh_root state =
-    unit_loop_no_args
-      ~description:(Fmt.str "Run du -sh on %s" (Paths.root state))
-      ["d"; "du-root"]
-      (fun () ->
-        Running_processes.run_cmdf state "du -sh %s" (Paths.root state)
-        >>= fun du ->
-        Console.display_errors_of_command state du
-        >>= function
-        | true ->
-            Console.say state
-              EF.(
-                desc (haf "Disk-Usage:")
-                  (af "%s" (String.concat ~sep:" " du#out)))
-        | false -> return ())
-
-  let processes state =
-    Console.Prompt.unit_and_loop
-      ~description:
-        "Display status of processes-manager ('all' to include non-running)"
-      ["p"; "processes"] (fun sxp ->
-        let all = flag "all" sxp in
-        Console.say state (Running_processes.ef ~all state))
-
-  let curl_rpc state ~port ~path =
-    Running_processes.run_cmdf state "curl http://localhost:%d/%s" port path
-    >>= fun curl_res ->
-    Console.display_errors_of_command state curl_res ~should_output:true
-    >>= fun success ->
-    if not success then return None
-    else
-      ( try
-          Ezjsonm.value_from_string (String.concat ~sep:"\n" curl_res#out)
-          |> return
-        with e -> cmdline_fail "Parsing JSON: %s" (Exn.to_string e) )
-      >>= fun json -> return (Some json)
-
-  let do_jq _state ~msg ~f = function
-    | None -> cmdline_fail "%s: No JSON" msg
-    | Some json -> (
-      try return (f json)
-      with e ->
-        cmdline_fail "%s: failed to analyze JSON: %s from %s" msg
-          (Exn.to_string e)
-          (Ezjsonm.value_to_string ~minify:false json) )
-
-  let curl_unit_display ?(jq = fun e -> e) ?pp_json state cmd ~default_port
-      ~path ~doc =
-    let pp_option =
-      Option.value_map pp_json ~default:[] ~f:(fun _ ->
-          [ Sexp_options.make_option "raw"
-              "Do not try to pretty print the output." ]) in
-    let get_pp_json _state sexps =
-      match pp_json with
-      | None -> return More_fmt.json
-      | Some _
-        when List.exists sexps
-               ~f:Sexp.(function List [Atom "raw"] -> true | _ -> false) ->
-          return More_fmt.json
-      | Some default -> return default in
-    Console.Prompt.unit_and_loop ~description:doc
-      ~details:
-        (Sexp_options.pp_options
-           (pp_option @ [Sexp_options.port_number_doc state ~default_port]))
-      cmd
-      (fun sexps ->
-        Sexp_options.port_number state sexps ~default_port
-        >>= fun port ->
-        get_pp_json state sexps
-        >>= fun pp_json ->
-        curl_rpc state ~port ~path
-        >>= fun json_opt ->
-        do_jq ~msg:doc state json_opt ~f:jq
-        >>= fun processed_json ->
-        Console.sayf state
-          More_fmt.(
-            fun ppf () ->
-              vertical_box ~indent:2 ppf (fun ppf ->
-                  pf ppf "Curl-node:%d -> %s" port doc ;
-                  cut ppf () ;
-                  pp_json ppf processed_json)))
-
-  let curl_metadata state ~default_port =
-    curl_unit_display state ["m"; "metadata"] ~default_port
-      ~path:"/chains/main/blocks/head/metadata"
-      ~doc:"Display `/chains/main/blocks/head/metadata`."
-
-  let curl_level state ~default_port =
-    curl_unit_display state ["l"; "level"] ~default_port
-      ~path:"/chains/main/blocks/head" ~doc:"Display current head block info."
-      ~pp_json:Tezos_protocol.Pretty_print.(verbatim_protection block_head_rpc)
-
-  let curl_baking_rights state ~default_port =
-    curl_unit_display state ["bk"; "baking-rights"] ~default_port
-      ~path:"/chains/main/blocks/head/helpers/baking_rights"
-      ~doc:"Display baking rights."
-
-  let all_levels state ~nodes =
-    unit_loop_no_args
-      ~description:"Get all “head” levels of all the nodes."
-      ["al"; "all-levels"] (fun () ->
-        Test_scenario.Queries.all_levels state ~nodes
-        >>= fun results ->
-        Console.say state
-          EF.(
-            desc (af "Node-levels:")
-              (list
-                 (List.map results ~f:(fun (id, result) ->
-                      desc (haf "%s" id)
-                        ( match result with
-                        | `Failed -> af "Failed"
-                        | `Level i -> af "[%d]" i
-                        | `Null -> af "{Null}"
-                        | `Unknown s -> af "¿%s?" s ))))))
-
-  let mempool state ~default_port =
-    curl_unit_display state ["mp"; "mempool"] ~default_port
-      ~path:"/chains/main/mempool/pending_operations"
-      ~doc:"Display the status of the mempool."
-      ~pp_json:
-        Tezos_protocol.Pretty_print.(
-          verbatim_protection mempool_pending_operations_rpc)
-
-  let show_process state =
-    Console.Prompt.unit_and_loop
-      ~description:"Show more of a process (by name-prefix)." ["show"]
-      (function
-      | [Atom name] ->
-          let prefix = String.lowercase name in
-          Running_processes.find_process_by_id state ~f:(fun n ->
-              String.is_prefix (String.lowercase n) ~prefix)
-          >>= fun procs ->
-          List.fold procs ~init:(return []) ~f:(fun prevm {process; lwt} ->
-              prevm
-              >>= fun prev ->
-              let open Running_processes in
-              let out = output_path state process `Stdout in
-              let err = output_path state process `Stderr in
-              Running_processes.run_cmdf state "tail %s" out
-              >>= fun tailout ->
-              Running_processes.run_cmdf state "tail %s" err
-              >>= fun tailerr ->
-              return
-                EF.(
-                  desc_list
-                    (haf "%S (%d)" process.Process.id lwt#pid)
-                    [ desc (af "out: %s" out) (ocaml_string_list tailout#out)
-                    ; desc (af "err: %s" err) (ocaml_string_list tailerr#out)
-                    ]
-                  :: prev))
-          >>= fun ef -> Console.say state EF.(list ef)
-      | _other -> cmdline_fail "command expects 1 argument: name-prefix")
-
-  let kill_all state =
-    unit_loop_no_args ~description:"Kill all known processes/process-groups."
-      ["ka"; "killall"] (fun () -> Running_processes.kill_all state)
-
-  let secret_keys state ~protocol =
-    unit_loop_no_args
-      ~description:"Show the protocol's “bootstrap” accounts."
-      ["boa"; "bootstrap-accounts"] (fun () ->
-        Console.sayf state
-          More_fmt.(
-            fun ppf () ->
-              vertical_box ~indent:0 ppf (fun ppf ->
-                  prompt ppf (fun ppf -> pf ppf "Bootstrap Accounts:") ;
-                  List.iter (Tezos_protocol.bootstrap_accounts protocol)
-                    ~f:(fun acc ->
-                      let open Tezos_protocol.Account in
-                      cut ppf () ;
-                      pf ppf "* Account %S:@," (name acc) ;
-                      pf ppf "  * Public Key Hash: %s@," (pubkey_hash acc) ;
-                      pf ppf "  * Public Key:      %s@," (pubkey acc) ;
-                      pf ppf "  * Private Key:     %s" (private_key acc)))))
-
-  let show_connections state nodes =
-    unit_loop_no_args ~description:"Show all node connections"
-      ["ac"; "all-connections"] (fun () ->
-        Helpers.dump_connections state nodes)
-
-  let balances state ~default_port =
-    Console.Prompt.unit_and_loop
-      ~description:"Show the balances of all known accounts."
-      ~details:
-        (Sexp_options.pp_options
-           [Sexp_options.port_number_doc state ~default_port])
-      ["sb"; "show-balances"]
-      (fun sexps ->
-        Sexp_options.port_number state sexps ~default_port
-        >>= fun port ->
-        curl_rpc state ~port ~path:"/chains/main/blocks/head/context/contracts"
-        >>= fun json_opt ->
-        do_jq state ~msg:"Getting contract list" ~f:Jqo.get_strings json_opt
-        >>= fun contracts ->
-        curl_rpc state ~port ~path:"/chains/main/checkpoint"
-        >>= fun chkpto ->
-        do_jq state chkpto ~msg:"Getting checkpoint"
-          ~f:
-            Jqo.(
-              fun json ->
-                match field ~k:"history_mode" json |> get_string with
-                | "archive" -> 1
-                | _ ->
-                    let sp = field ~k:"save_point" json |> get_int in
-                    Int.max 1 sp)
-        >>= fun save_point ->
-        let balance block contract =
-          let path =
-            sprintf "/chains/main/blocks/%s/context/contracts/%s/balance" block
-              contract in
-          curl_rpc state ~port ~path
-          >>= fun jo ->
-          do_jq state jo ~msg:"Getting balance" ~f:(fun j ->
-              Jqo.get_string j |> Int.of_string) in
-        List.fold contracts ~init:(return []) ~f:(fun prevm hsh ->
-            prevm
-            >>= fun prev ->
-            balance (Int.to_string save_point) hsh
-            >>= fun init ->
-            balance "head" hsh
-            >>= fun current -> return ((hsh, init, current) :: prev))
-        >>= fun results ->
-        Console.say state
-          EF.(
-            desc_list
-              (af "Balances from levels %d to “head” (port :%d)" save_point
-                 port)
-              (List.map results ~f:(fun (hsh, init, cur) ->
-                   let tz i = Float.of_int i /. 1_000_000. in
-                   desc (haf "%s:" hsh)
-                     ( if init = cur then af "%f (unchanged)" (tz cur)
-                     else af "%f → %f" (tz init) (tz cur) )))))
-
-  let better_call_dev state ~default_port =
-    Console.Prompt.unit_and_loop
-      ~description:"Show URIs to all contracts with `better-call.dev`."
-      ~details:
-        (Sexp_options.pp_options
-           [Sexp_options.port_number_doc state ~default_port])
-      ["bcd"; "better-call-dev"]
-      (fun sexps ->
-        Sexp_options.port_number state sexps ~default_port
-        >>= fun port ->
-        curl_rpc state ~port ~path:"/chains/main/blocks/head/context/contracts"
-        >>= fun json_opt ->
-        do_jq state ~msg:"Getting contract list" ~f:Jqo.get_strings json_opt
-        >>= fun contracts ->
-        let kt1s =
-          List.filter contracts ~f:(fun c -> String.is_prefix c ~prefix:"KT1")
-        in
-        Console.sayf state
-          Fmt.(
-            fun ppf () ->
-              vbox ~indent:2
-                (fun ppf () ->
-                  let block_url_arg =
-                    kstr Uri.pct_encode
-                      "blockUrl=http://127.0.0.1:%d/chains/main/blocks" port
-                  in
-                  let base =
-                    Environment_configuration.better_call_dev_base_url state
-                  in
-                  match kt1s with
-                  | [] ->
-                      pf ppf "There are no KT1 contracts in this sandbox." ;
-                      cut ppf () ;
-                      pf ppf "You can still go to %s?%s" base block_url_arg
-                  | some_kt1s ->
-                      pf ppf "Links:" ;
-                      cut ppf () ;
-                      List.iter some_kt1s ~f:(fun c ->
-                          if String.is_prefix c ~prefix:"KT1" then (
-                            pf ppf "* %s/%s/operations?%s" base c block_url_arg ;
-                            cut ppf () )))
-                ppf ()))
-
-  let arbitrary_command_on_all_clients ?make_admin
-      ?(command_names = ["atc"; "all-clients"]) state ~clients =
-    let details =
-      let open Sexp_options in
-      let only_opt =
-        make_option "only"
-          ~placeholders:["<name1>"; "<name2>"; "..."]
-          "Restrict the clients by name." in
-      let all =
-        (match clients with [_] -> [] | _ -> [only_opt])
-        @ Option.value_map make_admin ~default:[] ~f:(fun _ ->
-              [make_option "admin" "Use the admin-client instead."]) in
-      match all with [] -> None | _ -> Some (pp_options all) in
-    Console.Prompt.unit_and_loop
-      ~description:
-        (Fmt.str "Run a tezos-client command on %s"
-           ( match clients with
-           | [] -> "NO CLIENT, so this is useless…"
-           | [one] -> sprintf "the %S client." one.Tezos_client.id
-           | more ->
-               sprintf "all the following clients: %s."
-                 ( List.map more ~f:(fun c -> c.Tezos_client.id)
-                 |> String.concat ~sep:", " ) ))
-      ?details command_names
-      (fun sexps ->
-        let args =
-          let open Base.Sexp in
-          List.filter_map sexps ~f:(function Atom s -> Some s | _ -> None)
-        in
-        let subset_of_clients =
-          let open Base.Sexp in
-          List.find_map sexps ~f:(function
-            | List (Atom "only" :: l) ->
-                Some
-                  (List.map l ~f:(function
-                    | Atom a -> a
-                    | other ->
-                        ksprintf failwith
-                          "Option `only` only accepts a list of names: %s"
-                          (to_string_hum other)))
-            | _ -> None)
-          |> function
-          | None -> clients
-          | Some more ->
-              List.filter clients ~f:(fun c ->
-                  List.mem more c.Tezos_client.id ~equal:String.equal) in
-        let use_admin =
-          match make_admin with
-          | None -> `Client
-          | Some of_client ->
-              if
-                List.exists sexps
-                  ~f:
-                    Base.Sexp.(
-                      function List [Atom "admin"] -> true | _ -> false)
-              then `Admin of_client
-              else `Client in
-        List.fold ~init:(return []) subset_of_clients ~f:(fun prevm client ->
-            prevm
-            >>= fun prev ->
-            Running_processes.run_cmdf state "sh -c %s"
-              ( ( match use_admin with
-                | `Client -> Tezos_client.client_command state client args
-                | `Admin mkadm ->
-                    Tezos_admin_client.make_command state (mkadm client) args
-                )
-              |> Genspio.Compile.to_one_liner |> Caml.Filename.quote )
-            >>= fun res ->
-            Console.display_errors_of_command state res
-            >>= function
-            | true -> return ((client, String.concat ~sep:"\n" res#out) :: prev)
-            | false -> return prev)
-        >>= fun results ->
-        let different_results =
-          List.dedup_and_sort results ~compare:(fun (_, a) (_, b) ->
-              String.compare a b) in
-        Console.say state
-          EF.(
-            desc_list (af "Done")
-              [ desc (haf "Command:")
-                  (ocaml_string_list
-                     ( ( match use_admin with
-                       | `Client -> "<client>"
-                       | `Admin _ -> "<admin>" )
-                     :: args ))
-              ; desc (haf "Results")
-                  (list
-                     (List.map different_results ~f:(fun (_, res) ->
-                          let clients =
-                            List.filter_map results ~f:(function
-                              | c, r when String.equal res r ->
-                                  Some c.Tezos_client.id
-                              | _ -> None) in
-                          desc
-                            (haf "Client%s %s:"
-                               ( if List.length subset_of_clients = 1 then ""
-                               else "s" )
-                               (String.concat ~sep:", " clients))
-                            (markdown_verbatim res)))) ]))
-
-  let arbitrary_commands_for_each_client ?make_admin
-      ?(make_command_names = fun i -> [sprintf "c%d" i; sprintf "client-%d" i])
-      state ~clients =
-    List.mapi clients ~f:(fun i c ->
-        arbitrary_command_on_all_clients state ?make_admin ~clients:[c]
-          ~command_names:(make_command_names i))
-
-  let arbitrary_commands_for_each_and_all_clients ?make_admin
-      ?make_individual_command_names ?all_clients_command_names state ~clients
-      =
-    arbitrary_command_on_all_clients state ?make_admin ~clients
-      ?command_names:all_clients_command_names
-    :: arbitrary_commands_for_each_client state ?make_admin ~clients
-         ?make_command_names:make_individual_command_names
-
-  let protect_with_keyed_client msg ~client ~f =
-    let msg =
-      Fmt.str "Command-line %s with client %s (account: %s)" msg
-        client.Tezos_client.Keyed.client.id client.Tezos_client.Keyed.key_name
-    in
-    Asynchronous_result.bind_on_error (f ()) ~f:(fun ~result:_ ->
-      function
-      | #Process_result.Error.t as e ->
-          cmdline_fail "%s -> Error: %a" msg Process_result.Error.pp e
-      | #System_error.t as e ->
-          cmdline_fail "%s -> Error: %a" msg System_error.pp e
-      | `Command_line _ as e -> fail e)
-
-  let bake_command state ~clients =
-    Console.Prompt.unit_and_loop
-      ~description:
-        Fmt.(
-          str "Manually bake a block (with %s)."
-            ( match clients with
-            | [] -> "NO CLIENT, this is just wrong"
-            | [one] -> one.Tezos_client.Keyed.client.id
-            | m ->
-                str "one of %s"
-                  ( List.mapi m ~f:(fun ith one ->
-                        str "%d: %s" ith one.Tezos_client.Keyed.client.id)
-                  |> String.concat ~sep:", " ) ))
-      ["bake"]
-      (fun sexps ->
-        let client =
-          let open Base.Sexp in
-          match sexps with
-          | [] -> List.nth_exn clients 0
-          | [Atom s] -> List.nth_exn clients (Int.of_string s)
-          | _ -> Fmt.kstr failwith "Wrong command line: %a" pp (List sexps)
-        in
-        protect_with_keyed_client "manual-baking" ~client ~f:(fun () ->
-            Tezos_client.Keyed.bake state client "Manual baking !"))
-
-  let generate_traffic_command state ~clients =
-    Console.Prompt.unit_and_loop
-      ~description:
-        Fmt.(
-          str "Generate traffic from a client (%s); try `gen help`."
-            ( match clients with
-            | [] -> "NO CLIENT, this is just wrong"
-            | [one] -> one.Tezos_client.Keyed.client.id
-            | m ->
-                str "use option (client ..) with one of %s"
-                  ( List.mapi m ~f:(fun ith one ->
-                        str "%d: %s" ith one.Tezos_client.Keyed.client.id)
-                  |> String.concat ~sep:", " ) ))
-      ["generate"; "gen"]
-      (fun sexps ->
-        let client =
-          let open Sexp in
-          match
-            List.find_map sexps ~f:(function
-              | List [Atom "client"; Atom s] ->
-                  Some (List.nth_exn clients (Int.of_string s))
-              | _ -> None)
-          with
-          | None -> List.nth_exn clients 0
-          | Some c -> c
-          | exception _ ->
-              Fmt.kstr failwith "Wrong command line: %a" pp (List sexps) in
-        let counter_option =
-          Sexp_options.make_option "counter" ~placeholders:["<int>"]
-            "The counter to provide (get it from the node by default)." in
-        let size_option =
-          Sexp_options.make_option "size" ~placeholders:["<int>"]
-            "The batch size (default: 10)." in
-        let fee_option =
-          Sexp_options.make_option "fee" ~placeholders:["<float-tz>"]
-            "The fee per operation (default: 0.02)." in
-        let level_option =
-          Sexp_options.make_option "level" ~placeholders:["<int>"] "The level."
-        in
-        let branch client =
-          Tezos_client.rpc state ~client:client.Tezos_client.Keyed.client `Get
-            ~path:"/chains/main/blocks/head/hash"
-          >>= fun br ->
-          let branch = Jqo.get_string br in
-          return branch in
-        match sexps with
-        | Atom "help" :: __ ->
-            Console.sayf state
-              More_fmt.(
-                let cmd ppf name desc options =
-                  cut ppf () ;
-                  vertical_box ~indent:2 ppf (fun ppf ->
-                      pf ppf "* Command `gen %s ...`:" name ;
-                      cut ppf () ;
-                      wrapping_box ppf (fun ppf -> desc ppf ()) ;
-                      cut ppf () ;
-                      Sexp_options.pp_options options ppf ()) in
-                fun ppf () ->
-                  pf ppf "Generating traffic: TODO" ;
-                  cmd ppf "batch"
-                    (const text
-                       "Make a batch operation (only transfers for now).")
-                    [counter_option; size_option; fee_option] ;
-                  cmd ppf "endorsement"
-                    (const text "Make an endorsement for a given level")
-                    [level_option])
-        | Atom "endorsement" :: more_args ->
-            protect_with_keyed_client "forge-and-inject" ~client ~f:(fun () ->
-                branch client
-                >>= fun branch ->
-                Sexp_options.get level_option more_args
-                  ~f:Sexp_options.get_int_exn ~default:(fun () -> return 42)
-                >>= fun level ->
-                let json = Traffic_generation.Forge.endorsement ~branch level in
-                Tezos_client.Keyed.forge_and_inject state client ~json
-                >>= fun json_result ->
-                Console.sayf state
-                  More_fmt.(fun ppf () -> json ppf json_result))
-        | Atom "batch" :: more_args ->
-            protect_with_keyed_client "forge-and-inject" ~client ~f:(fun () ->
-                branch client
-                >>= fun branch ->
-                let src =
-                  client.key_name |> Tezos_protocol.Account.of_name
-                  |> Tezos_protocol.Account.pubkey_hash in
-                Sexp_options.get counter_option more_args
-                  ~f:Sexp_options.get_int_exn ~default:(fun () ->
-                    Tezos_client.rpc state ~client:client.client `Get
-                      ~path:
-                        (Fmt.str
-                           "/chains/main/blocks/head/context/contracts/%s/counter"
-                           src)
-                    >>= fun counter_json ->
-                    return ((Jqo.get_string counter_json |> Int.of_string) + 1))
-                >>= fun counter ->
-                Sexp_options.get size_option more_args
-                  ~f:Sexp_options.get_int_exn ~default:(fun () -> return 10)
-                >>= fun size ->
-                Sexp_options.get fee_option more_args
-                  ~f:Sexp_options.get_float_exn ~default:(fun () ->
-                    return 0.02)
-                >>= fun fee ->
-                let json =
-                  Traffic_generation.Forge.batch_transfer ~src ~counter ~fee
-                    ~branch size in
-                Tezos_client.Keyed.forge_and_inject state client ~json
-                >>= fun json_result ->
-                Console.sayf state
-                  More_fmt.(fun ppf () -> json ppf json_result))
-        | other ->
-            Fmt.kstr failwith "Wrong command line: %a" Sexp.pp (List other))
-
-  let all_defaults state ~nodes =
-    let default_port = (List.hd_exn nodes).Tezos_node.rpc_port in
-    [ du_sh_root state; processes state
-    ; show_connections state nodes
-    ; curl_level state ~default_port
-    ; balances state ~default_port
-    ; curl_metadata state ~default_port
-    ; curl_baking_rights state ~default_port
-    ; mempool state ~default_port
-    ; better_call_dev state ~default_port
-    ; all_levels state ~nodes; show_process state; kill_all state ]
-end
-
-module Interactivity = struct
-  type t = [`Full | `None | `On_error | `At_end]
-
-  let is_interactive (state : < test_interactivity: t ; .. >) =
-    Poly.equal state#test_interactivity `Full
-
-  let pause_on_error state =
-    match state#test_interactivity with
-    | `Full | `On_error | `At_end -> true
-    | `None -> false
-
-  let pause_on_success state =
-    match state#test_interactivity with
-    | `Full | `At_end -> true
-    | `None | `On_error -> false
-
-  let cli_term ?(default : t = `None) () =
-    let open Cmdliner in
-    Term.(
-      pure (fun interactive pause_end pause_error ->
-          match (interactive, pause_end, pause_error) with
-          | true, _, _ -> `Full
-          | false, true, _ -> `At_end
-          | false, false, true -> `On_error
-          | false, false, false -> `None)
-      $ Arg.(
-          value
-          & opt bool
-              ( match default with
-              | `None | `On_error | `At_end -> false
-              | `Full -> true )
-          & info ["interactive"] ~doc:"Add all pauses with command prompts.")
-      $ Arg.(
-          value
-          & opt bool
-              ( match default with
-              | `None | `On_error -> false
-              | `At_end | `Full -> true )
-          & info ["pause-at-end"]
-              ~doc:"Add a pause with a command prompt at the end of the test.")
-      $ Arg.(
-          value
-          & opt bool
-              ( match default with
-              | `None -> false
-              | `At_end | `Full | `On_error -> true )
-          & info ["pause-on-error"]
-              ~doc:
-                "Add a pause with a command prompt at the end of the test, \
-                 only in case of test failure."))
-end
-
-module Pauser = struct
-  type t =
-    { mutable extra_commands: Console.Prompt.item list
-    ; default_end: [`Sleep of float] }
-
-  let make ?(default_end = `Sleep 0.5) extra_commands =
-    {extra_commands; default_end}
-
-  let commands state = state#pauser.extra_commands
-  let default_end state = state#pauser.default_end
-
-  let add_commands state cl =
-    state#pauser.extra_commands <- commands state @ cl
-
-  let generic state ?(force = false) msgs =
-    let do_pause = Interactivity.is_interactive state || force in
-    Console.say state
-      EF.(
-        desc
-          (if do_pause then haf "Pause" else haf "Not pausing")
-          (list ~param:{default_list with space_before_separator= false} msgs))
-    >>= fun () ->
-    if do_pause then Console.Prompt.(command state ~commands:(commands state))
-    else return ()
-
-  let run_test state f ~pp_error () =
-    let finish () =
-      Console.say state EF.(af "Killing all processes.")
-      >>= fun () ->
-      Running_processes.kill_all state
-      >>= fun () ->
-      Console.say state EF.(af "Waiting for processes to all die.")
-      >>= fun () -> Running_processes.wait_all state in
-    Caml.Sys.catch_break false ;
-    let cond = Lwt_condition.create () in
-    let catch_signals () =
-      Lwt_unix.on_signal Caml.Sys.sigint (fun i ->
-          Caml.Printf.eprintf
-            "\nReceived signal SIGINT (%d), type `q` to quit prompts.\n\n%!" i ;
-          Lwt_condition.broadcast cond `Sig_int)
-      |> ignore ;
-      Lwt_unix.on_signal Caml.Sys.sigterm (fun i ->
-          Caml.Printf.eprintf
-            "\nReceived signal SIGTERM (%d), type `q` to quit prompts.\n\n%!" i ;
-          Lwt_condition.broadcast cond `Sig_term)
-      |> ignore in
-    let wait_on_signals () =
-      System_error.catch Lwt_condition.wait cond
-      >>= fun sig_name -> return (`Woken_up_by_signal sig_name) in
-    Dbg.e
-      EF.(wf "Running test %s on %s" state#application_name (Paths.root state)) ;
-    let wrap_result f = f () >>= fun o -> return (`Successful_procedure o) in
-    let run_with_signal_catching ~name procedure =
-      Lwt.(
-        pick
-          [ ( wrap_result (fun () -> procedure ())
-            >>= fun res ->
-            match res.Attached_result.result with
-            | Ok _ ->
-                Dbg.e EF.(wf "Procedure %s ended: ok" name) ;
-                return res
-            | Error (`System_error (_, System_error.Exception Lwt.Canceled)) ->
-                Dbg.e EF.(wf "Procedure %s was cancelled" name) ;
-                System.sleep 2.
-                >>= fun _ ->
-                Dbg.e EF.(wf "Procedure %s slept 2." name) ;
-                return res
-            | Error e ->
-                Dbg.e
-                  EF.(wf "Procedure %s ended with error %a" name pp_error e) ;
-                return res )
-          ; ( wait_on_signals ()
-            >>= fun res ->
-            Dbg.e EF.(wf "Signal-wait %S go woken up" name) ;
-            return res ) ]) in
-    let last_pause_status = ref `Not_done in
-    let rec protect ~name procedure =
-      catch_signals () ;
-      Dbg.e EF.(wf "protecting %S" name) ;
-      let last_pause () =
-        protect ~name:"Last-pause" (fun () ->
-            generic state ~force:true
-              EF.
-                [ haf
-                    "Last pause before the application will Kill 'Em All and \
-                     Quit." ]
-            >>= fun () ->
-            last_pause_status := `Done ;
-            return ()) in
-      Asynchronous_result.bind_all
-        ( try
-            Dbg.e EF.(wf "protecting: %S in-try" name) ;
-            run_with_signal_catching ~name procedure
-          with e ->
-            System_error.fail_fatalf
-              ~attach:[("protected", `String_value name)]
-              "protecting %S: ocaml-exn: %a" name Exn.pp e )
-        ~f:(fun result ->
-          match result.result with
-          | Ok (`Successful_procedure o) -> return (`Was_ok o)
-          | Ok (`Woken_up_by_signal `Sig_term) ->
-              Console.say state
-                EF.(
-                  desc (shout "Received SIGTERM")
-                    (wf
-                       "Will not pause because it's the wrong thing to do; \
-                        killing everything and quitting."))
-              >>= fun () -> return `Quit_with_error
-          | Ok (`Woken_up_by_signal `Sig_int) ->
-              Console.say state
-                EF.(
-                  desc (shout "Received SIGINT")
-                    (wf
-                       "Please the command `q` (a.k.a. `quit`) for quitting \
-                        prompts."))
-              >>= fun () -> return `Error_that_can_be_interactive
-          | Error (`System_error (`Fatal, System_error.Exception End_of_file))
-            ->
-              Console.say state
-                EF.(
-                  desc
-                    (shout "Received End-of-File (Ctrl-D?)")
-                    (wf
-                       "Cannot pause because interactivity broken; killing \
-                        everything and quitting."))
-              >>= fun () -> return `Quit_with_error
-          | Error _ ->
-              Console.say state
-                EF.(
-                  desc
-                    (shout "An error happened")
-                    (custom (fun ppf ->
-                         Attached_result.pp ~pp_error ppf result)))
-              >>= fun () -> return `Error_that_can_be_interactive)
-      >>= fun todo_next ->
-      match todo_next with
-      | `Was_ok ()
-        when Interactivity.pause_on_success state
-             && Poly.equal !last_pause_status `Not_done ->
-          last_pause ()
-      | `Was_ok () -> (
-          finish ()
-          >>= fun () ->
-          match default_end state with
-          | `Sleep n ->
-              Console.say state EF.(wf "Test done, sleeping %.02f seconds" n)
-              >>= fun () -> System.sleep n )
-      | `Error_that_can_be_interactive when Interactivity.pause_on_error state
-        ->
-          last_pause ()
-      | `Error_that_can_be_interactive | `Quit_with_error ->
-          finish () >>= fun () -> Asynchronous_result.die 4 in
-    protect f ~name:"Main-function"
-    >>= fun () ->
-    Dbg.e EF.(wf "Finishing Interactive_test.run_test") ;
-    return ()
-end
diff --git a/vendors/flextesa-lib/interactive_test.mli b/vendors/flextesa-lib/interactive_test.mli
deleted file mode 100644
index f599234dd3ce6d75deaeb81604c4db119cd0e1d3..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/interactive_test.mli
+++ /dev/null
@@ -1,261 +0,0 @@
-(** Tools to manage interactivity in test scenarios. *)
-
-open Internal_pervasives
-
-(** Implementations of common {!Console.Prompt.item}. *)
-module Commands : sig
-  val cmdline_fail :
-       ( 'a
-       , Caml.Format.formatter
-       , unit
-       , ('b, [> `Command_line of string]) Asynchronous_result.t )
-       format4
-    -> 'a
-
-  val no_args :
-    'a list -> (unit, [> `Command_line of string]) Asynchronous_result.t
-
-  val flag : string -> Sexplib0.Sexp.t list -> bool
-
-  val unit_loop_no_args :
-       description:string
-    -> string list
-    -> (   unit
-        -> ( unit
-           , [`Command_line of string | System_error.t] )
-           Asynchronous_result.t)
-    -> Console.Prompt.item
-
-  val du_sh_root :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> Console.Prompt.item
-
-  val processes :
-       < application_name: string
-       ; console: Console.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> Console.Prompt.item
-
-  val curl_rpc :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> port:int
-    -> path:string
-    -> ( Ezjsonm.value option
-       , [> `Command_line of string | System_error.t] )
-       Asynchronous_result.t
-
-  val do_jq :
-       < application_name: string ; console: Console.t ; paths: Paths.t ; .. >
-    -> msg:string
-    -> f:(Ezjsonm.value -> 'b)
-    -> Ezjsonm.value option
-    -> ('b, [> `Command_line of string]) Asynchronous_result.t
-
-  val curl_unit_display :
-       ?jq:(Ezjsonm.value -> Ezjsonm.value)
-    -> ?pp_json:(Formatter.t -> Ezjsonm.value -> unit)
-    -> < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> string list
-    -> default_port:int
-    -> path:string
-    -> doc:string
-    -> Console.Prompt.item
-
-  val curl_metadata :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> default_port:int
-    -> Console.Prompt.item
-
-  val curl_level :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> default_port:int
-    -> Console.Prompt.item
-
-  val curl_baking_rights :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> default_port:int
-    -> Console.Prompt.item
-
-  val all_levels :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> nodes:Tezos_node.t list
-    -> Console.Prompt.item
-
-  val show_process :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> Console.Prompt.item
-
-  val kill_all :
-    < runner: Running_processes.State.t ; .. > -> Console.Prompt.item
-
-  val secret_keys :
-       < application_name: string ; console: Console.t ; .. >
-    -> protocol:Tezos_protocol.t
-    -> Console.Prompt.item
-
-  val better_call_dev :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> default_port:int
-    -> Console.Prompt.item
-
-  val arbitrary_command_on_all_clients :
-       ?make_admin:(Tezos_client.t -> Tezos_admin_client.t)
-    -> ?command_names:string list
-    -> < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> clients:Tezos_client.t list
-    -> Console.Prompt.item
-
-  val arbitrary_commands_for_each_client :
-       ?make_admin:(Tezos_client.t -> Tezos_admin_client.t)
-    -> ?make_command_names:(int -> string list)
-    -> < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> clients:Tezos_client.t list
-    -> Console.Prompt.item list
-
-  val arbitrary_commands_for_each_and_all_clients :
-       ?make_admin:(Tezos_client.t -> Tezos_admin_client.t)
-    -> ?make_individual_command_names:(int -> string list)
-    -> ?all_clients_command_names:string list
-    -> < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> clients:Tezos_client.t list
-    -> Console.Prompt.item list
-
-  val bake_command :
-       < application_name: string
-       ; console: Console.t
-       ; operations_log: Log_recorder.Operations.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> clients:Tezos_client.Keyed.t list
-    -> Console.Prompt.item
-
-  val generate_traffic_command :
-       < application_name: string
-       ; console: Console.t
-       ; operations_log: Log_recorder.Operations.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> clients:Tezos_client.Keyed.t list
-    -> Console.Prompt.item
-
-  val all_defaults :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> nodes:Tezos_node.t list
-    -> Console.Prompt.item list
-end
-
-(** Configurable (through {!Cmdliner.Term.t}) interactivity of
-    test-scenarios. *)
-module Interactivity : sig
-  type t = [`Full | `None | `On_error | `At_end]
-
-  val pause_on_error : < test_interactivity: t ; .. > -> bool
-  val pause_on_success : < test_interactivity: t ; .. > -> bool
-  val is_interactive : < test_interactivity: t ; .. > -> bool
-  val cli_term : ?default:t -> unit -> t Cmdliner.Term.t
-end
-
-(** A {!Pauser.t} is tool to include optional prompting pauses in
-    test-scenarios. *)
-module Pauser : sig
-  type t = private
-    { mutable extra_commands: Console.Prompt.item list
-    ; default_end: [`Sleep of float] }
-
-  val make : ?default_end:[`Sleep of float] -> Console.Prompt.item list -> t
-
-  val add_commands : < pauser: t ; .. > -> Console.Prompt.item list -> unit
-  (** Add commands to the current pauser. *)
-
-  val generic :
-       < application_name: string
-       ; console: Console.t
-       ; pauser: t
-       ; test_interactivity: Interactivity.t
-       ; .. >
-    -> ?force:bool
-    -> Easy_format.t list
-    -> (unit, [> System_error.t]) Asynchronous_result.t
-  (** Pause the test according to [state#interactivity] (overridden
-      with [~force:true]), the pause displays the list of
-      {!Easy_format.t}s and prompts the user for commands (see
-      {!add_commands}). *)
-
-  val run_test :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; pauser: t
-       ; runner: Running_processes.State.t
-       ; test_interactivity: Interactivity.t
-       ; .. >
-    -> (unit -> (unit, ([> System_error.t] as 'errors)) Asynchronous_result.t)
-    -> pp_error:(Caml.Format.formatter -> 'errors -> unit)
-    -> unit
-    -> (unit, [> System_error.t | `Die of int]) Asynchronous_result.t
-  (** Run a test-scenario and deal with potential errors according
-      to [state#test_interactivity]. *)
-end
diff --git a/vendors/flextesa-lib/internal_pervasives.ml b/vendors/flextesa-lib/internal_pervasives.ml
deleted file mode 100644
index 51819bb648738a01488cedcdef0756bf879bbc85..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/internal_pervasives.ml
+++ /dev/null
@@ -1,552 +0,0 @@
-(** Local “Pervasives” module for flextesa.
-
-See also ["docs/tutorials/flextesa.rst"]. *)
-
-include Base
-
-let ( // ) = Caml.Filename.concat
-let ksprintf, sprintf = Printf.(ksprintf, sprintf)
-
-(** Wrapper around the [EasyFormat] library to use for console display. *)
-module EF = struct
-  type t = Easy_format.t
-
-  open Easy_format
-
-  let default_list = list
-  let default_atom = atom
-  let default_label = label
-  let atom ?(param = default_atom) s = Atom (s, param)
-  let label ?(param = label) a b = Label ((a, param), b)
-
-  let list ?(delimiters = ("", "")) ?(sep = "") ?(param = default_list) l =
-    List ((fst delimiters, sep, snd delimiters, param), l)
-
-  let ocaml_list = list ~delimiters:("[", "]") ~sep:";"
-
-  let ocaml_tuple =
-    list ~delimiters:("(", ")") ~sep:","
-      ~param:
-        { default_list with
-          space_after_opening= false
-        ; space_before_closing= false }
-
-  let shout = atom ~param:{atom_style= Some "shout"}
-  let prompt = atom ~param:{atom_style= Some "prompt"}
-  let highlight = atom ~param:{atom_style= Some "prompt"}
-  let custom pr = Custom pr
-  let pr f = custom (fun ppf -> f (Fmt.pf ppf))
-  let desc_list s l = label s (list ~sep:"," l)
-  let desc s v = label s v
-  let af ?param fmt = Fmt.kstr (atom ?param) fmt
-
-  let wrap s =
-    String.split ~on:' ' s |> List.map ~f:String.strip
-    |> List.filter ~f:(Fn.non (String.equal ""))
-    |> List.map ~f:atom |> list
-
-  let wf fmt = Fmt.kstr wrap fmt
-  let haf fmt = Fmt.kstr highlight fmt
-  let opt f = function None -> atom "-" | Some o -> f o
-  let ocaml_string_list l = ocaml_list (List.map l ~f:(af "%S"))
-  let exn e = wf "%a" Exn.pp e
-
-  let markdown_verbatim ?(guard_length = 80) s =
-    let guard = String.make guard_length '`' in
-    af "\n%s\n%s\n%s@." guard s guard
-
-  let ef_json msg json =
-    desc (haf "%s" msg)
-      (markdown_verbatim Ezjsonm.(to_string ~minify:false (wrap json)))
-end
-
-(** Debug-display module (non-cooperative output to [stderr]). *)
-module Dbg = struct
-  let on = ref false
-
-  let () =
-    Option.iter (Caml.Sys.getenv_opt "FLEXTESA_DEBUG") ~f:(function
-      | "true" -> on := true
-      | _ -> ())
-
-  let e ef =
-    if !on then (
-      EF.(
-        list ~delimiters:("<DBG|", "|DBG>") ~sep:""
-          ~param:
-            { default_list with
-              separator_style= Some "debug"
-            ; align_closing= true
-            ; space_after_opening= true
-            ; space_before_closing= true }
-          [ef]
-        |> Easy_format.Pretty.to_stderr) ;
-      Fmt.epr "\n%!" )
-
-  let i (e : EF.t) = ignore e
-  let f f = e (EF.pr f)
-  let any v = Dum.to_eformat v
-  let pp_any fmt v = Dum.to_formatter fmt v
-end
-
-module More_fmt = struct
-  include Fmt
-  (** Little experiment for fun … *)
-
-  let vertical_box ?indent ppf f = vbox ?indent (fun ppf () -> f ppf) ppf ()
-  let wrapping_box ?indent ppf f = box ?indent (fun ppf () -> f ppf) ppf ()
-
-  let wf ppf fmt =
-    Fmt.kstr (fun s -> box (fun ppf () -> text ppf s) ppf ()) fmt
-
-  let markdown_verbatim_list ppf l =
-    vertical_box ~indent:0 ppf (fun ppf ->
-        cut ppf () ;
-        string ppf (String.make 45 '`') ;
-        List.iter l ~f:(fun l -> cut ppf () ; string ppf l) ;
-        cut ppf () ;
-        string ppf (String.make 45 '`'))
-
-  let tag tag ppf f =
-    Caml.Format.(pp_open_stag ppf (String_tag tag)) ;
-    (f ppf : unit) ;
-    Caml.Format.pp_close_stag ppf ()
-
-  let shout = tag "shout"
-  let prompt = tag "prompt"
-
-  let long_string ?(max = 30) ppf s =
-    match String.sub s ~pos:0 ~len:(max - 2) with
-    | s -> pf ppf "%S" (s ^ "...")
-    | exception _ -> pf ppf "%S" s
-
-  let json ppf json =
-    markdown_verbatim_list ppf
-      (Ezjsonm.value_to_string ~minify:false json |> String.split ~on:'\n')
-end
-
-(** An “decorated result type” based on polymorphic variants *)
-module Attached_result = struct
-  type content =
-    [ `Text of string
-    | `String_value of string
-    | `Verbatim of string list
-    | `String_list of string list ]
-
-  type ('ok, 'error) t =
-    {result: ('ok, 'error) Result.t; attachments: (string * content) list}
-    constraint 'error = [> ]
-
-  let ok ?(attachments = []) o = {result= Ok o; attachments}
-  let error ?(attachments = []) o = {result= Error o; attachments}
-
-  let pp ppf ?pp_ok ?pp_error {result= the_result; attachments} =
-    let open More_fmt in
-    let result_part ppf =
-      match the_result with
-      | Ok o ->
-          wrapping_box ~indent:4 ppf (fun ppf ->
-              prompt ppf (fun ppf -> pf ppf "OK") ;
-              Option.iter pp_ok ~f:(fun ppo -> pf ppf ":@ %a." ppo o))
-      | Error e ->
-          wrapping_box ~indent:4 ppf (fun ppf ->
-              shout ppf (fun ppf -> pf ppf "Error") ;
-              Option.iter pp_error ~f:(fun ppe -> pf ppf ":@ %a." ppe e)) in
-    match attachments with
-    | [] -> result_part ppf
-    | more ->
-        vertical_box ~indent:0 ppf (fun ppf ->
-            result_part ppf ;
-            List.iter more ~f:(fun (k, v) ->
-                cut ppf () ;
-                wrapping_box ppf ~indent:2 (fun ppf ->
-                    pf ppf "* " ;
-                    prompt ppf (fun ppf -> string ppf k) ;
-                    match v with
-                    | `Text t -> pf ppf ": %a" text t
-                    | `String_value s -> pf ppf ": %S" s
-                    | `String_list sl ->
-                        pf ppf ": [" ;
-                        cut ppf () ;
-                        wrapping_box ~indent:2 ppf (fun ppf ->
-                            list ~sep:sp (fun ppf -> pf ppf "%S;") ppf sl ;
-                            pf ppf "]")
-                    | `Verbatim [] -> pf ppf ": EMPTY"
-                    | `Verbatim sl ->
-                        pf ppf ":" ;
-                        let lines =
-                          let sep = String.make 50 '`' in
-                          (sep :: List.drop sl (List.length sl - 20)) @ [sep]
-                        in
-                        cut ppf () ;
-                        vertical_box ~indent:0 ppf (fun ppf ->
-                            list ~sep:cut string ppf lines))))
-end
-
-(** A wrapper around [('ok, 'a Error.t) result Lwt.t]. *)
-module Asynchronous_result = struct
-  open Attached_result
-
-  type ('ok, 'error) t = ('ok, 'error) Attached_result.t Lwt.t
-
-  let return o : (_, _) t = Lwt.return (ok o)
-
-  let yield () =
-    (* https://github.com/ocsigen/lwt/issues/631 *)
-    if false then Lwt_unix.auto_yield 0.005 () else Lwt.pause ()
-
-  let fail ?attach error_value : (_, _) t =
-    Lwt.return (error ?attachments:attach error_value)
-
-  (* let error e : (_, _) t = Lwt.return (error e) *)
-
-  let bind (o : (_, _) t) f : (_, _) t =
-    let open Lwt.Infix in
-    o
-    >>= function
-    | {result= Ok o; attachments= attach} ->
-        yield ()
-        >>= fun () ->
-        f o
-        >>= fun {result; attachments} ->
-        Lwt.return {result; attachments= attachments @ attach}
-    | {result= Error _; _} as e -> Lwt.return e
-
-  let bind_on_error :
-         ('a, 'b) t
-      -> f:(   result:('c, 'b) Attached_result.t
-            -> 'b
-            -> ('a, 'd) Attached_result.t Lwt.t)
-      -> ('a, 'd) t =
-   fun o ~f ->
-    let open Lwt.Infix in
-    o
-    >>= function
-    | {result= Ok _; _} as o -> Lwt.return o
-    | {result= Error e; attachments= attach} as res ->
-        f ~result:res e
-        >>= fun {result; attachments} ->
-        Lwt.return
-          { result
-          ; attachments=
-              List.dedup_and_sort ~compare:Poly.compare (attachments @ attach)
-          }
-
-  let transform_error o ~f =
-    let open Lwt.Infix in
-    o
-    >>= function
-    | {result= Ok _; _} as o -> Lwt.return o
-    | {result= Error e; attachments} ->
-        Lwt.return {result= Error (f e); attachments}
-
-  let enrich : attachment:(string * content) list -> 'a -> ('b, 'c) t =
-   fun ~attachment x ->
-    bind_on_error x ~f:(fun ~result _ ->
-        Lwt.return
-          Attached_result.
-            {result with attachments= result.attachments @ attachment})
-
-  let bind_all :
-         ('ok, 'error) t
-      -> f:(('ok, 'error) Attached_result.t -> ('ok2, 'error2) t)
-      -> ('ok2, 'error2) t =
-   fun o ~f ->
-    let open Lwt.Infix in
-    o >>= fun res -> f res
-
-  let bind_on_result :
-         ('ok, 'error) t
-      -> f:(('ok, 'error) Result.t -> ('ok2, 'error2) t)
-      -> ('ok2, 'error2) t =
-   fun o ~f ->
-    let open Lwt.Infix in
-    o
-    >>= fun {result; attachments= attach} ->
-    f result
-    >>= fun {result; attachments} ->
-    Lwt.return {result; attachments= attachments @ attach}
-
-  (** The module opened everywhere. *)
-  module Std = struct
-    let ( >>= ) = bind let ( let* ) = bind let return = return let fail = fail
-  end
-
-  open Std
-
-  let run r on_error =
-    match Lwt_main.run (r ()) with Ok o -> o | Error e -> on_error e
-
-  let die n = fail (`Die n)
-
-  module List_sequential = struct
-    let iter l ~f =
-      List.fold l ~init:(return ()) ~f:(fun pm x ->
-          pm >>= fun () -> (f x : (_, _) t))
-
-    let iteri l ~f =
-      List.fold l ~init:(return 0) ~f:(fun pm x ->
-          pm >>= fun n -> (f n x : (_, _) t) >>= fun () -> return (n + 1))
-      >>= fun _ -> return ()
-  end
-
-  let map_option o ~f =
-    match o with
-    | None -> return None
-    | Some s -> f s >>= fun o -> return (Some o)
-
-  module Loop = struct
-    let n_times times f =
-      let rec loop n =
-        match n with
-        | n when n <= 0 -> return ()
-        | n -> f (1 + times - n) >>= fun () -> loop (n - 1) in
-      loop times
-  end
-
-  module Stream = struct
-    let fold :
-           'elt Lwt_stream.t
-        -> f:('b -> 'elt -> ('b, 'error) t)
-        -> init:'b
-        -> ('b, 'error) t =
-     fun stream ~f ~init ->
-      let error = ref None in
-      Lwt.catch
-        (fun () ->
-          Lwt_stream.fold_s
-            (fun elt prevm ->
-              match prevm.result with
-              | Ok x -> f x elt
-              | Error _ ->
-                  error := Some prevm ;
-                  Lwt.fail Caml.Not_found)
-            stream (Attached_result.ok init))
-        (fun e ->
-          match !error with
-          | Some res -> Lwt.return res
-          | None ->
-              (* `f` threw a forbidden exception! *)
-              Lwt.fail e)
-  end
-
-  let run_application r =
-    Lwt_main.at_exit
-      Lwt.(
-        fun () ->
-          Dbg.e EF.(wf "Lwt-at-exit: run_application") ;
-          return ()) ;
-    match
-      Lwt_main.run
-        Lwt.(
-          Lwt.pause ()
-          >>= fun () ->
-          Dbg.e EF.(wf "Lwt_main.run") ;
-          r ())
-    with
-    | {result= Ok (); _} -> Caml.exit 0
-    | {result= Error (`Die ret); _} -> Caml.exit ret
-end
-
-include Asynchronous_result.Std
-module List_sequential = Asynchronous_result.List_sequential
-module Loop = Asynchronous_result.Loop
-
-module System_error = struct
-  type static = Exception of exn | Message of string
-  type t = [`System_error of [`Fatal] * static]
-
-  let fatal e : [> t] = `System_error (`Fatal, e)
-  let fatal_message e : [> t] = `System_error (`Fatal, Message e)
-  let fail_fatal ?attach e = fail ?attach (`System_error (`Fatal, e) : [> t])
-
-  let catch ?attach f x =
-    Lwt.catch
-      (fun () -> Lwt.bind (f x) @@ fun r -> return r)
-      (fun exn -> fail_fatal ?attach (Exception exn))
-
-  let catch_exn ?attach f =
-    try return (f ()) with exn -> fail_fatal ?attach (Exception exn)
-
-  let fail_fatalf ?attach fmt =
-    Fmt.kstr (fun e -> fail_fatal ?attach (Message e)) fmt
-
-  let pp fmt (e : [< t]) =
-    match e with
-    | `System_error (`Fatal, e) ->
-        Fmt.pf fmt "@[<2>Fatal-system-error:@ %a@]"
-          (fun ppf -> function Exception e -> Fmt.exn ppf e
-            | Message e -> Fmt.string ppf e)
-          e
-end
-
-(** A wrapper around a structural type describing the result of
-    external processes. *)
-module Process_result = struct
-  type t =
-    < err: string list ; out: string list ; status: Unix.process_status >
-
-  let status_to_string s =
-    Lwt_unix.(
-      match s with
-      | WEXITED n -> sprintf "exited with %d" n
-      | WSIGNALED n -> sprintf "was signaled: %d" n
-      | WSTOPPED n -> sprintf "was stopped: %d" n)
-
-  module Error = struct
-    type error =
-      | Wrong_status of {status: Unix.process_status; message: string}
-      | Wrong_behavior of {message: string}
-
-    type res = t
-    type t = [`Process_error of error]
-
-    let make error = (`Process_error error : [> t])
-    let fail ?attach error = Asynchronous_result.fail ?attach (make error)
-
-    let wrong_status ?attach result msgf =
-      Fmt.kstr
-        (fun message ->
-          let attach =
-            Option.value attach ~default:[]
-            @ [ ("stdout", `Verbatim result#out)
-              ; ("stderr", `Verbatim result#err) ] in
-          fail ~attach (Wrong_status {status= result#status; message}))
-        msgf
-
-    let wrong_behavior ?attach msgf =
-      Fmt.kstr (fun message -> fail ?attach (Wrong_behavior {message})) msgf
-
-    let pp ppf (`Process_error the_error) =
-      let open More_fmt in
-      wrapping_box ppf (fun ppf ->
-          pf ppf "Process-error:" ;
-          sp ppf () ;
-          match the_error with
-          | Wrong_status {status; message} ->
-              text ppf message ;
-              pf ppf "; wrong-status: '%s'." (status_to_string status)
-          | Wrong_behavior {message} -> text ppf message)
-
-    let fail_if_non_zero (res : res) msg =
-      if Poly.( <> ) res#status (Unix.WEXITED 0) then
-        wrong_status res "Non-zero exit status: %s" msg
-      else return ()
-  end
-end
-
-(** The state within this library is packed into an open object
-    (structural) type, this module just defines the [application_name]
-    method. *)
-module Base_state = struct
-  type base = < application_name: string >
-  type 'a t = 'a constraint 'a = < base ; .. >
-end
-
-module Manpage_builder = struct
-  module Section = struct
-    let test_scenario = "TEST SCENARIO OPTIONS"
-    let environment_variables = Cmdliner.Manpage.s_environment
-    let executables = "EXECUTABLE PATHS"
-  end
-
-  module Env_variables = struct
-    type doc = Lines of string list
-
-    let man all_known : Cmdliner.Manpage.block list =
-      [`S Section.environment_variables]
-      @ List.map all_known ~f:(fun (name, Lines lines) ->
-            `I (name, String.concat ~sep:"\n" lines))
-  end
-
-  module State = struct
-    type t =
-      { mutable used_sections: (int * string * Cmdliner.Manpage.block list) list
-      ; mutable env_variables: (string * Env_variables.doc) list }
-
-    let make () = {used_sections= []; env_variables= []}
-    let _state state = state#manpager
-
-    let add_section ?(man = []) state ~rank ~name =
-      let t = _state state in
-      match
-        List.find t.used_sections ~f:(fun (_, n, _) -> String.equal n name)
-      with
-      | None -> t.used_sections <- (rank, name, man) :: t.used_sections
-      | Some _ -> ()
-
-    let all_sections state : Cmdliner.Manpage.block list list =
-      let t = _state state in
-      List.sort t.used_sections ~compare:Base.Poly.ascending
-      |> List.map ~f:(fun (_, s, man) -> `S s :: man)
-
-    let register_env_variable state name lines =
-      let t = _state state in
-      t.env_variables <- (name, Env_variables.Lines lines) :: t.env_variables
-  end
-
-  let section ?man state ~rank ~name =
-    State.add_section ?man state ~rank ~name ;
-    name
-
-  let section_test_scenario state =
-    State.add_section state ~rank:0 ~name:Section.test_scenario ;
-    Section.test_scenario
-
-  let make state ~intro_blob extra : Cmdliner.Manpage.block list =
-    let sections = State.all_sections state in
-    List.concat
-      [ [`P intro_blob]; extra; List.concat sections
-      ; Env_variables.man state#manpager.State.env_variables
-      ; [`S Cmdliner.Manpage.s_options] ]
-end
-
-(** Some {!Lwt_unix} functions. *)
-module System = struct
-  let sleep f = System_error.catch Lwt_unix.sleep f
-
-  let write_file (_state : _ Base_state.t) ?perm path ~content =
-    System_error.catch
-      (fun () ->
-        Lwt_io.with_file ?perm ~mode:Lwt_io.output path (fun out ->
-            Lwt_io.write out content))
-      ()
-
-  let read_file (_state : _ Base_state.t) path =
-    System_error.catch
-      (fun () ->
-        Lwt_io.with_file ~mode:Lwt_io.input path (fun out -> Lwt_io.read out))
-      ()
-end
-
-(** WIP [jq]-like manipulation in pure OCaml. *)
-module Jqo = struct
-  let of_string s = Ezjsonm.from_string s
-  let to_string j = Ezjsonm.(to_string (wrap j))
-  let of_lines l = Ezjsonm.value_from_string (String.concat ~sep:"\n" l)
-
-  let field ~k = function
-    | `O l -> List.Assoc.find_exn l ~equal:String.equal k
-    | other -> ksprintf failwith "Jqo.field (%S) in %s" k (to_string other)
-
-  let list_find ~f = function
-    | `O l ->
-        List.find_map_exn ~f:(fun (_, j) -> if f j then Some j else None) l
-    | `A l -> List.find_exn ~f l
-    | other -> ksprintf failwith "Jqo.list_find in %s" (to_string other)
-
-  let list_exists ~f o =
-    match list_find o ~f with _ -> true | exception _ -> false
-
-  let remove_field o ~name =
-    match o with
-    | `O l -> `O (List.filter l ~f:Poly.(fun (k, _) -> k <> name))
-    | other ->
-        ksprintf failwith "Jqo.remove_field %S: No an object: %s" name
-          (to_string other)
-
-  let get_string = Ezjsonm.get_string
-  let get_strings = Ezjsonm.get_strings
-  let get_int = Ezjsonm.get_int
-  let get_list = Ezjsonm.get_list (fun e -> e)
-end
diff --git a/vendors/flextesa-lib/kiln.ml b/vendors/flextesa-lib/kiln.ml
deleted file mode 100644
index 199d4cb18af22a9d4a278c0e1de3df5f3502583b..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/kiln.ml
+++ /dev/null
@@ -1,112 +0,0 @@
-open Internal_pervasives
-
-module Configuration_directory = struct
-  type t = {path: string; clean: bool; p2p_port: int}
-
-  let generate state ?(protocol_execs = []) t ~peers ~sandbox_json ~nodes
-      ~bakers ~network_string ~node_exec ~client_exec =
-    (* For now, client-exec in Kiln is not protocol dependent, this
-     should be fixed soon. *)
-    let {path; clean; p2p_port} = t in
-    ( if clean then
-      Running_processes.run_cmdf state
-        "rm -fr %s ; mkdir -p %s ; chmod -R 777 %s" path path path
-      >>= fun _ -> return ()
-    else return () )
-    >>= fun _ ->
-    System.write_file state ~perm:0o777 (path // "loggers")
-      ~content:
-        Ezjsonm.(
-          `A
-            [ dict
-                [ ("logger", dict [("Stderr", dict [])])
-                ; ( "filters"
-                  , dict [("SQL", string "Error"); ("", string "Info")] ) ] ]
-          |> to_string)
-    (* {json|[{ "logger":{"Stderr":{}} , "filters": { "SQL":"Error" , "":"Info"}}]|json} *)
-    >>= fun () ->
-    let node_config = path // "node-config.json" in
-    System.write_file state ~perm:0o777 node_config
-      ~content:
-        Ezjsonm.(
-          dict
-            [ ("data-dir", string (path // "node-data-dir-unused"))
-            ; ("rpc", dict [("listen-addr", string "127.0.0.1")])
-            ; ("p2p", dict [("expected-proof-of-work", int 1)]) ]
-          |> to_string)
-    >>= fun () ->
-    System.write_file state ~perm:0o777
-      (path // "kiln-node-net-port")
-      ~content:(sprintf "%d" p2p_port)
-    >>= fun () ->
-    let pwd = Caml.Sys.getenv "PWD" in
-    let absolutize path =
-      if Caml.Filename.is_relative path then pwd // path else path in
-    System.write_file state ~perm:0o777
-      (path // "kiln-node-custom-args")
-      ~content:
-        (sprintf
-           "--config-file %s --private-mode --no-bootstrap-peers %s  \
-            --synchronisation-threshold 0 --connections %d --sandbox %s"
-           (absolutize node_config)
-           ( List.map peers ~f:(sprintf "--peer 127.0.0.1:%d")
-           |> String.concat ~sep:" " )
-           (List.length peers - 1)
-           sandbox_json)
-    >>= fun () ->
-    System.write_file state ~perm:0o777 (path // "nodes")
-      ~content:(String.concat ~sep:"," nodes)
-    >>= fun () ->
-    System.write_file state ~perm:0o777 (path // "bakers")
-      ~content:
-        ( List.map bakers ~f:(fun (n, addr) -> sprintf "%s@%s" addr n)
-        |> String.concat ~sep:"," )
-    >>= fun () ->
-    System.write_file state ~perm:0o777 (path // "network")
-      ~content:network_string
-    >>= fun () ->
-    System.write_file state ~perm:0o777
-      (path // "enable-obsidian-node")
-      ~content:(sprintf "%b" false)
-    >>= fun () ->
-    System.write_file state ~perm:0o777 (path // "binary-paths")
-      ~content:
-        Ezjsonm.(
-          let absolutize exec =
-            let path = Tezos_executable.get exec in
-            absolutize path in
-          dict
-            [ ("node-path", string (absolutize node_exec))
-            ; ("client-path", string (absolutize client_exec))
-            ; ( "baker-endorser-paths"
-              , list
-                  (fun (p, bak, endo) ->
-                    strings [p; absolutize bak; absolutize endo])
-                  protocol_execs ) ]
-          |> to_string ~minify:false)
-    >>= fun () ->
-    Running_processes.run_cmdf state " chmod -R 777 %s" path
-    >>= fun _ -> return ()
-
-  let cli_term state =
-    let open Cmdliner in
-    let docs = Manpage_builder.section state ~rank:4 ~name:"TOOLS: KILN" in
-    Term.(
-      pure (fun x clean ->
-          Option.map x ~f:(fun (path, p2p_port) -> {path; p2p_port; clean}))
-      $ Arg.(
-          value
-            (opt
-               (some (pair ~sep:',' string int))
-               None
-               (info ~docs
-                  ["generate-kiln-configuration-path"]
-                  ~docv:"PATH,PORT"
-                  ~doc:"Generate a kiln configuration at $(docv)")))
-      $ Arg.(
-          value
-            (flag
-               (info ~docs
-                  ["clean-kiln-configuration"]
-                  ~doc:"Delete configuration path before generating it"))))
-end
diff --git a/vendors/flextesa-lib/kiln.mli b/vendors/flextesa-lib/kiln.mli
deleted file mode 100644
index 292994b6fb71e6c2c44ef90d77b7c9a941700a3b..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/kiln.mli
+++ /dev/null
@@ -1,27 +0,0 @@
-(** Helpers to run Kiln with a network-sandbox. *)
-
-open Internal_pervasives
-
-(** Generate Kiln ["./config/"] directories from sandbox parameters. *)
-module Configuration_directory : sig
-  type t = {path: string; clean: bool; p2p_port: int}
-
-  val generate :
-       < application_name: string
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> ?protocol_execs:(string * Tezos_executable.t * Tezos_executable.t) list
-    -> t
-    -> peers:int list
-    -> sandbox_json:string
-    -> nodes:string list
-    -> bakers:(string * string) list
-    -> network_string:string
-    -> node_exec:Tezos_executable.t
-    -> client_exec:Tezos_executable.t
-    -> (unit, [> System_error.t]) Asynchronous_result.t
-
-  val cli_term :
-    < manpager: Manpage_builder.State.t ; .. > -> t option Cmdliner.Term.t
-end
diff --git a/vendors/flextesa-lib/liquidity.ml b/vendors/flextesa-lib/liquidity.ml
deleted file mode 100644
index 77dad9c58e758c5cc87ba2ea3d6efc758035c083..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/liquidity.ml
+++ /dev/null
@@ -1,345 +0,0 @@
-open Internal_pervasives
-module MFmt = Experiments.Markup_fmt
-
-let failf ?attach fmt =
-  ksprintf (fun s -> fail ?attach (`Scenario_error s)) fmt
-
-module Data = struct
-  type t = Fmt of (Caml.Format.formatter -> unit)
-
-  let to_string = function
-    | Fmt f -> Caml.Format.asprintf "%a" (fun ppf () -> f ppf) ()
-
-  let pp ppf (Fmt f) =
-    let open Fmt in
-    box (fun ppf () -> f ppf) ppf ()
-
-  let rawf fmt =
-    Caml.Format.kasprintf (fun s -> Fmt (fun ppf -> Fmt.string ppf s)) fmt
-
-  let fmt f = Fmt f
-  let address s = rawf "%s" s
-
-  let list_like ~sep ~delimiter l =
-    Fmt
-      Fmt.(
-        fun ppf ->
-          delimiter
-            (fun ppf () -> list ~sep (fun ppf (Fmt f) -> f ppf) ppf l)
-            ppf ())
-
-  let tuple l = list_like ~sep:Fmt.comma ~delimiter:Fmt.parens l
-  let int i = Fmt (fun ppf -> Fmt.int ppf i)
-  let string = rawf "%S"
-  let nat d = rawf "%dp" d
-
-  let tez (`Mutez d) =
-    let million = 1_000_000. in
-    rawf "%ftz" (Float.of_int d /. million)
-
-  let semi_colon = Fmt.(fun ppf () -> string ppf ";" ; sp ppf ())
-  let list l = list_like ~sep:semi_colon ~delimiter:Fmt.brackets l
-
-  let set l =
-    list_like ~sep:semi_colon l
-      ~delimiter:Fmt.(fun x ppf -> pf ppf "@[<6>(Set [%a]@])" x)
-
-  let empty_set = set []
-  let key_hash s = rawf "%s" s
-  let key s = rawf "%s" s
-  let account_key a = Tezos_protocol.Account.pubkey a |> key
-  let account_key_hash a = Tezos_protocol.Account.pubkey_hash a |> key_hash
-  let signature s = rawf "%s" s
-  let bytes s = rawf "0x%s" s
-  let some s = fmt (fun ppf -> Fmt.pf ppf "@[<5>(Some %a)@]" pp s)
-  let none = rawf "None"
-  let typed_none t = rawf "(None : %s)" t
-
-  let record l =
-    list_like ~sep:semi_colon ~delimiter:Fmt.braces
-      (List.map l ~f:(fun (k, v) ->
-           fmt Fmt.(fun ppf -> pf ppf "@[<2>%s =@ %a@]" k pp v)))
-end
-
-module Contract = struct
-  type t = {name: string; paths: string list; main_name: string option}
-
-  let make ?(library = []) ?main_name name ~path =
-    {name; paths= library @ [path]; main_name}
-
-  let build_dir state t =
-    Paths.root state // sprintf "liquidity-build-%s" t.name
-
-  let ensure_build_dir state t =
-    let dir = build_dir state t in
-    Running_processes.run_successful_cmdf state "mkdir -p %s"
-      (Caml.Filename.quote dir)
-    >>= fun _ -> return dir
-
-  let base_liquidity_command _state t =
-    sprintf "liquidity %s %s"
-      (List.map t.paths ~f:Caml.Filename.quote |> String.concat ~sep:" ")
-      (Option.value_map t.main_name ~default:"" ~f:(sprintf "--main %s"))
-
-  let michelson state t =
-    let f = build_dir state t // sprintf "%s.tz" t.name in
-    ensure_build_dir state t
-    >>= fun _ ->
-    Running_processes.run_successful_cmdf state "%s --no-annot -o %s"
-      (base_liquidity_command state t)
-      (Caml.Filename.quote f)
-    >>= fun _ -> return f
-
-  let storage_initialization state t ~tezos_node ~storage =
-    ensure_build_dir state t
-    >>= fun dir ->
-    let out = dir // sprintf "%s-initial-storage.tz" t.name in
-    Running_processes.run_successful_cmdf state
-      "%s -o %s --tezos-node %s --init-storage %s"
-      (base_liquidity_command state t)
-      (Caml.Filename.quote out)
-      (Caml.Filename.quote tezos_node)
-      ( List.map storage ~f:(fun item ->
-            Caml.Filename.quote (Data.to_string item))
-      |> String.concat ~sep:" " )
-    >>= fun _ -> System.read_file state out >>= fun content -> return content
-
-  let arguments state t ~entry_point ~data =
-    Running_processes.run_successful_cmdf state "%s --data %s %s"
-      (base_liquidity_command state t)
-      (Caml.Filename.quote entry_point)
-      (Caml.Filename.quote (Data.to_string data))
-    >>= fun res -> return (String.concat ~sep:" " res#out)
-
-  let cmdliner_term ~prefix ~name () =
-    let contract_name = name in
-    let open Cmdliner in
-    let open Term in
-    let flag_name s = sprintf "%s-%s" prefix s in
-    Arg.(
-      pure (fun path main_name library ->
-          make ~library ?main_name ~path contract_name)
-      $ required
-          (opt (some non_dir_file) None
-             (info [flag_name "path"]
-                ~doc:
-                  (sprintf "Path to the liquidity %s contract." contract_name)))
-      $ value
-          (opt (some string) None
-             (info [flag_name "main"]
-                ~doc:
-                  (sprintf "Name of “main” contract for %s." contract_name)))
-      $ value
-          (opt
-             (list ~sep:',' non_dir_file)
-             []
-             (info [flag_name "library"]
-                ~doc:
-                  (sprintf
-                     "Paths to extra liquidity %s contract-library files."
-                     contract_name))))
-end
-
-module On_chain = struct
-  let tezos_client_keyed_originate_contract ?(force = false)
-      ?(transferring = 0) ?(burn_cap = 0.5) state keyed ~name ~source ~storage
-      =
-    let client = keyed.Tezos_client.Keyed.client in
-    Tezos_client.successful_client_cmd state ~client
-      ( [ "--wait"; "none"; "originate"; "contract"; name; "for"; keyed.key_name
-        ; "transferring"; Int.to_string transferring; "from"; keyed.key_name
-        ; "running"; source; "--init"; storage; "--burn-cap"
-        ; Float.to_string burn_cap ]
-      @ if force then ["--force"] else [] )
-
-  let build_and_deploy ?(burn_cap = 10.1) state contract ~keyed_client ~storage
-      ~balance =
-    let name = contract.Contract.name in
-    let tezos_node =
-      sprintf "http://localhost:%d" keyed_client.Tezos_client.Keyed.client.port
-    in
-    Contract.michelson state contract
-    >>= fun michetz ->
-    Contract.storage_initialization state contract ~tezos_node
-      ~storage:(List.map storage ~f:snd)
-    >>= fun init ->
-    tezos_client_keyed_originate_contract state keyed_client ~name
-      ~transferring:balance ~source:michetz ~storage:init ~burn_cap ~force:true
-    >>= fun _ ->
-    Tezos_client.Keyed.bake state keyed_client (sprintf "%s origination" name)
-    >>= fun () ->
-    Tezos_client.successful_client_cmd state
-      ~client:keyed_client.Tezos_client.Keyed.client
-      ["show"; "known"; "contract"; name]
-    >>= fun res ->
-    let address = String.strip (String.concat ~sep:"" res#out) in
-    Console.sayf state
-      MFmt.(
-        par (t "Deployed " @ hlf "“%s”" name)
-        @ itemize [tf "Script: `%s`" michetz; tf "Address: `%s`" address]
-        @ par (tf "Storage:")
-        @ itemize
-            (List.map storage ~f:(fun (name, data) ->
-                 tf "%s:@ %a" name Data.pp data))
-        |> to_fmt)
-    >>= fun () -> return address
-
-  (* This should go to flextesa soon... *)
-  let silent_client_cmd state ~client args =
-    Running_processes.run_cmdf state "sh -c %s"
-      ( Tezos_client.client_command state client args
-      |> Genspio.Compile.to_one_liner |> Caml.Filename.quote )
-    >>= fun res ->
-    let success = Poly.equal res#status (Lwt_unix.WEXITED 0) in
-    return (success, res)
-
-  let call ?msg ?(should = `Be_ok) ?(transferring = 0) ?(burn_cap = 0.3) state
-      contract ~keyed_client ~entry_point ~data =
-    Contract.arguments state contract ~entry_point ~data
-    >>= fun low_level_arg ->
-    silent_client_cmd state ~client:keyed_client.Tezos_client.Keyed.client
-      [ "--wait"; "none"; "transfer"; Int.to_string transferring; "from"
-      ; keyed_client.key_name; "to"; contract.name; "--burn-cap"
-      ; Float.to_string burn_cap; "--arg"; low_level_arg ]
-    >>= fun (succeeds, res) ->
-    ( match succeeds with
-    | false -> (
-      match should with
-      | `Fail -> return (`Expected `Failure)
-      | `Script_failwith_re re ->
-          let interesting_part =
-            List.drop_while res#err ~f:(fun line ->
-                String.is_prefix line ~prefix:"script reached FAILWITH")
-            |> String.concat ~sep:" " in
-          if Re.execp re interesting_part then return (`Expected `Failure)
-          else return (`Failed `With_error_does_not_match)
-      | `Command_stderr_re re ->
-          if Re.execp re (String.concat ~sep:"\n" res#err) then
-            return (`Expected `Failure)
-          else return (`Failed `With_error_does_not_match)
-      | `Be_ok -> return (`Failed `Not_ok) )
-    | true when Poly.equal should `Be_ok ->
-        silent_client_cmd state ~client:keyed_client.client
-          [ "bake"; "for"; keyed_client.key_name; "--force"
-          ; "--minimal-timestamp" ]
-        >>= fun (_bake, _) -> return (`Expected `Ok)
-    | true (* should is no ok *) -> return (`Failed `Unexpected_ok) )
-    >>= fun test_status ->
-    let test_full_name =
-      sprintf "%s#%s%s" contract.name entry_point
-        (Option.value_map msg ~default:"" ~f:(sprintf " (%s)")) in
-    Console.sayf state
-      MFmt.(
-        let details =
-          match test_status with
-          | `Expected _ -> []
-          | `Failed _ ->
-              par (tf "Data:")
-              @ verbatim [Data.to_string data]
-              @ par (tf "Std-out:")
-              @ verbatim res#out
-              @ par (tf "Std-err:")
-              @ verbatim res#err in
-        par (tf "Test-call %s" test_full_name)
-        @ itemize
-            [ ( match test_status with
-              | `Expected exp ->
-                  hlf "Success: %s"
-                    ( match exp with
-                    | `Ok -> "op-baked"
-                    | `Failure -> "expected-failure" )
-              | `Failed reason ->
-                  hlf "FAILURE: %s"
-                    ( match reason with
-                    | `Not_ok -> "Not-OK"
-                    | `Unexpected_ok -> "Should-have-failed"
-                    | `With_error_does_not_match ->
-                        "Error-message-does-not-match" ) ) ]
-        @ details
-        |> to_fmt)
-    >>= fun () ->
-    match test_status with
-    | `Expected _ -> return res
-    | `Failed _ -> failf "Test failed: %s" test_full_name
-
-  let key_with_type_json key =
-    let open Ezjsonm in
-    match key with
-    | `Nat n ->
-        ( dict [("int", `String (Int.to_string n))]
-        , dict [("prim", `String "nat")] )
-
-  let big_map_get state ~client ~address ~key =
-    let post_json =
-      let open Ezjsonm in
-      let k, t = key_with_type_json key in
-      dict [("key", k); ("type", t)] |> to_string ~minify:false in
-    Tezos_client.rpc state ~client (`Post post_json)
-      ~path:
-        (sprintf "/chains/main/blocks/head/context/contracts/%s/big_map_get"
-           address)
-    >>= fun json ->
-    return
-      (object
-         method post = post_json
-
-         method result = json
-      end)
-
-  let show_contract_command state ~client ~name ~address ~pp_error =
-    Console.Prompt.unit_and_loop
-      ~description:(Fmt.str "Show status of the contract %s." address)
-      [sprintf "show-%s" name] (fun _sexps ->
-        Asynchronous_result.transform_error
-          ~f:(fun e ->
-            Caml.Format.kasprintf
-              (fun s -> `Command_line s)
-              "show-contract: %a" pp_error e)
-          ( List.fold ["storage"; "balance"] ~init:(return [])
-              ~f:(fun pm endpoint ->
-                pm
-                >>= fun l ->
-                Tezos_client.rpc state ~client `Get
-                  ~path:
-                    (sprintf "/chains/main/blocks/head/context/contracts/%s/%s"
-                       address endpoint)
-                >>= fun json ->
-                return
-                  EF.(
-                    desc (wf "/%s" endpoint)
-                      (markdown_verbatim
-                         (Ezjsonm.value_to_string ~minify:false json))
-                    :: l))
-          >>= fun l ->
-          Console.say state
-            EF.(
-              desc
-                (haf "Contract %s@%s" name address)
-                (list ~sep:"" ~delimiters:("", "") l)) ))
-
-  let big_map_get_command state ~names ~thing ~client ~name ~address
-      ~key_of_string ~pp_error =
-    Console.Prompt.unit_and_loop
-      ~description:
-        (Fmt.str "Get %s from the big-map of the contract %s@%s." thing name
-           address) names (fun sexps ->
-        Asynchronous_result.transform_error
-          ~f:(fun e ->
-            Caml.Format.kasprintf
-              (fun s -> `Command_line s)
-              "%s: %a" (List.hd_exn names) pp_error e)
-          ( match sexps with
-          | [Sexplib.Sexp.Atom s] ->
-              key_of_string s
-              >>= fun key ->
-              big_map_get state ~client ~address ~key
-              >>= fun getthing ->
-              Console.sayf state
-                MFmt.(
-                  par (tf "Posted:")
-                  @ verbatim_raw getthing#post
-                  @ par (tf "Got:")
-                  @ verbatim_ezjson getthing#result
-                  |> to_fmt)
-          | _ -> failf "Wrong s-exp command line" ))
-end
diff --git a/vendors/flextesa-lib/liquidity.mli b/vendors/flextesa-lib/liquidity.mli
deleted file mode 100644
index f5a447a68e0c42d7030a0a54119c1319040c754d..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/liquidity.mli
+++ /dev/null
@@ -1,200 +0,0 @@
-open Internal_pervasives
-
-module Data : sig
-  type t
-
-  val to_string : t -> string
-  val rawf : ('a, Caml.Format.formatter, unit, t) format4 -> 'a
-  val empty_set : t
-  val address : string -> t
-  val tuple : t list -> t
-  val int : int -> t
-  val string : string -> t
-  val nat : int -> t
-  val tez : [`Mutez of int] -> t
-  val list : t list -> t
-  val set : t list -> t
-  val key_hash : string -> t
-  val key : string -> t
-  val account_key : Tezos_protocol.Account.t -> t
-  val account_key_hash : Tezos_protocol.Account.t -> t
-  val signature : string -> t
-  val bytes : string -> t
-  val some : t -> t
-  val none : t
-  val typed_none : string -> t
-  val record : (string * t) list -> t
-end
-
-module Contract : sig
-  type t = private {name: string; paths: string list; main_name: string option}
-
-  val make :
-    ?library:string list -> ?main_name:string -> string -> path:string -> t
-
-  val build_dir : < paths: Paths.t ; .. > -> t -> string
-
-  val ensure_build_dir :
-       < paths: Paths.t ; runner: Running_processes.State.t ; .. > Base_state.t
-    -> t
-    -> ( string
-       , [> System_error.t | Process_result.Error.t] )
-       Asynchronous_result.t
-
-  val base_liquidity_command : 'a -> t -> string
-
-  val michelson :
-       < paths: Paths.t ; runner: Running_processes.State.t ; .. > Base_state.t
-    -> t
-    -> ( string
-       , [> System_error.t | Process_result.Error.t] )
-       Asynchronous_result.t
-
-  val storage_initialization :
-       < application_name: string
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> t
-    -> tezos_node:string
-    -> storage:Data.t list
-    -> ( string
-       , [> System_error.t | Process_result.Error.t] )
-       Asynchronous_result.t
-
-  val arguments :
-       < paths: Paths.t ; runner: Running_processes.State.t ; .. > Base_state.t
-    -> t
-    -> entry_point:string
-    -> data:Data.t
-    -> ( string
-       , [> System_error.t | Process_result.Error.t] )
-       Asynchronous_result.t
-
-  val cmdliner_term : prefix:string -> name:string -> unit -> t Cmdliner.Term.t
-end
-
-module On_chain : sig
-  val tezos_client_keyed_originate_contract :
-       ?force:bool
-    -> ?transferring:int
-    -> ?burn_cap:float
-    -> < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> Tezos_client.Keyed.t
-    -> name:string
-    -> source:string
-    -> storage:string
-    -> ( Process_result.t
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val build_and_deploy :
-       ?burn_cap:float
-    -> < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; operations_log: Log_recorder.Operations.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> Contract.t
-    -> keyed_client:Tezos_client.Keyed.t
-    -> storage:(string * Data.t) list
-    -> balance:int
-    -> ( string
-       , [> Process_result.Error.t | System_error.t | Process_result.Error.t]
-       )
-       Asynchronous_result.t
-
-  val silent_client_cmd :
-       < paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-       Base_state.t
-    -> client:Tezos_client.t
-    -> string list
-    -> (bool * Process_result.t, [> System_error.t]) Asynchronous_result.t
-
-  val call :
-       ?msg:string
-    -> ?should:[ `Be_ok
-               | `Fail
-               | `Script_failwith_re of Re.re
-               | `Command_stderr_re of Re.re ]
-    -> ?transferring:int
-    -> ?burn_cap:float
-    -> < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> Contract.t
-    -> keyed_client:Tezos_client.Keyed.t
-    -> entry_point:string
-    -> data:Data.t
-    -> ( Process_result.t
-       , [> System_error.t | `Scenario_error of string | Process_result.Error.t]
-       )
-       Asynchronous_result.t
-
-  val key_with_type_json : [< `Nat of int] -> [> Ezjsonm.t] * [> Ezjsonm.t]
-
-  val big_map_get :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:Tezos_client.t
-    -> address:string
-    -> key:[< `Nat of int]
-    -> ( < post: string ; result: Ezjsonm.value >
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val show_contract_command :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:Tezos_client.t
-    -> name:string
-    -> address:string
-    -> pp_error:(   Caml.Format.formatter
-                 -> [> Process_result.Error.t | System_error.t]
-                 -> unit)
-    -> Console.Prompt.item
-
-  val big_map_get_command :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> names:string list
-    -> thing:string
-    -> client:Tezos_client.t
-    -> name:string
-    -> address:string
-    -> key_of_string:(   string
-                      -> ( [< `Nat of int]
-                         , ([> Process_result.Error.t
-                            | System_error.t
-                            | `Scenario_error of string ]
-                            as
-                            'errors) )
-                         Asynchronous_result.t)
-    -> pp_error:(Caml.Format.formatter -> 'errors -> unit)
-    -> Console.Prompt.item
-end
diff --git a/vendors/flextesa-lib/log_recorder.ml b/vendors/flextesa-lib/log_recorder.ml
deleted file mode 100644
index 13aca07a7295c854606b32470ffed0d3bc33d9c8..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/log_recorder.ml
+++ /dev/null
@@ -1,43 +0,0 @@
-open Internal_pervasives
-
-module Operations = struct
-  (* This is likely a temporary module, which will be obsoleted by a
-     more general framework. *)
-  type t =
-    { mutable operations:
-        [ `Bake of string * string * string list
-        | `Endorse of string * string * string list
-        | `Transfer of string * string * string * string list ]
-        list }
-
-  let make () = {operations= []}
-  let from_state state : t = state#operations_log
-
-  let show_all state =
-    let t = from_state state in
-    Console.Prompt.unit_and_loop ~description:"Show all manual operations"
-      ["ao"; "all-ops"; "all-operations"] (fun _ ->
-        Console.say state
-          EF.(
-            desc_list (haf "Operations:")
-              (List.rev_map t.operations ~f:(function
-                | `Transfer (cli, msg, dest, res) ->
-                    desc_list (haf "Transfer: %S" cli)
-                      [ af "→ %s" msg; af "dest: %s" dest
-                      ; ocaml_string_list res ]
-                | `Endorse (n, msg, res) ->
-                    desc_list
-                      (haf "Node-endorsed: %S" n)
-                      [af "→ %s" msg; ocaml_string_list res]
-                | `Bake (n, msg, res) ->
-                    desc_list (haf "Node-baked: %S" n)
-                      [af "→ %s" msg; ocaml_string_list res]))))
-
-  let bake state ~client ~output msg =
-    let t = from_state state in
-    t.operations <- `Bake (client, msg, output) :: t.operations
-
-  let endorse state ~client ~output msg =
-    let t = from_state state in
-    t.operations <- `Endorse (client, msg, output) :: t.operations
-end
diff --git a/vendors/flextesa-lib/paths.ml b/vendors/flextesa-lib/paths.ml
deleted file mode 100644
index 751273155bdda4ad7f8a9f55f962ce486d372134..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/paths.ml
+++ /dev/null
@@ -1,22 +0,0 @@
-open Internal_pervasives
-
-type t = {root: string}
-
-let make root =
-  { root=
-      ( if Caml.Filename.is_relative root then Caml.Sys.getcwd () // root
-      else root ) }
-
-let root_path o = o.root
-let pp fmt o = Fmt.pf fmt "@[<2>{Root:@ %s}@]" (root_path o)
-let ob o : t = o#paths
-let root o = ob o |> root_path
-
-let cli_term ?(option_name = "root-path") ~default_root () =
-  Cmdliner.(
-    Term.(
-      pure make
-      $ Arg.(
-          value & opt string default_root
-          & info [option_name]
-              ~doc:(sprintf "Root path for all configs/data to use."))))
diff --git a/vendors/flextesa-lib/paths.mli b/vendors/flextesa-lib/paths.mli
deleted file mode 100644
index 4e4cc8aa89822511fa5e98a19e8c9a11a6880907..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/paths.mli
+++ /dev/null
@@ -1,12 +0,0 @@
-(** Configure and manipulate a “root-path.”   *)
-
-type t
-
-val make : string -> t
-val pp : Format.formatter -> t -> unit
-
-val root : < paths: t ; .. > -> string
-(** Query the configured root-path. *)
-
-val cli_term :
-  ?option_name:string -> default_root:string -> unit -> t Cmdliner.Term.t
diff --git a/vendors/flextesa-lib/running_processes.ml b/vendors/flextesa-lib/running_processes.ml
deleted file mode 100644
index c33da268e0a09ff15777eafb85b66c6e84fb5064..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/running_processes.ml
+++ /dev/null
@@ -1,326 +0,0 @@
-open Internal_pervasives
-
-module Process = struct
-  type kind =
-    [`Process_group | `Docker of string | `Process_group_script of string]
-
-  type t = {id: string; binary: string option; command: string list; kind: kind}
-
-  let make_in_session ?binary id kind command =
-    {id; binary; command= "setsid" :: command; kind}
-
-  let genspio id script =
-    let script_content =
-      Fmt.str "%a" Genspio.Compile.To_slow_flow.Script.pp_posix
-        (Genspio.Compile.To_slow_flow.compile script) in
-    let command = ["sh"] in
-    make_in_session id (`Process_group_script script_content) command
-
-  let docker_run id ~image ~options ~args =
-    let name = id in
-    let command =
-      ["docker"; "run"; "--name"; name; "--rm"] @ options @ [image] @ args
-    in
-    {id; binary= None; command; kind= `Docker name}
-end
-
-module State = struct
-  type process_state = {process: Process.t; lwt: Lwt_process.process_none}
-  type t = {processes: (string, process_state) Caml.Hashtbl.t}
-
-  let pp fmt {processes} =
-    let open Caml.Format in
-    fprintf fmt "Processes:@ [@[" ;
-    Caml.Hashtbl.iter
-      (fun s {lwt; _} -> fprintf fmt "%S:%d" s lwt#pid)
-      processes ;
-    fprintf fmt "]@]"
-
-  let make () = {processes= Caml.Hashtbl.create 42}
-  let processes o = (o#runner : t).processes
-
-  let add_process o process lwt =
-    Caml.Hashtbl.add (processes o) process.Process.id {process; lwt} ;
-    return ()
-
-  let all_processes t =
-    let res = ref [] in
-    Caml.Hashtbl.iter (fun _ t -> res := t :: !res) (processes t) ;
-    return !res
-end
-
-open State
-open Process
-
-let output_path t process which =
-  let sanitize =
-    String.map ~f:(function '\'' | '/' | '"' -> '_' | other -> other) in
-  Paths.root t
-  // ( "output"
-     // sanitize process.Process.id
-     //
-     match which with
-     | `Stdout -> "stdout.log"
-     | `Stderr -> "stderr.log"
-     | `Meta -> "meta.log"
-     | `Script -> "script.sh" )
-
-let ef_processes state processes =
-  EF.(
-    desc_list (af "Processes")
-      (List.map processes ~f:(fun {process; lwt} ->
-           desc_list (af "P:%s" process.id)
-             [ desc (af "out") (atom (output_path state process `Stdout))
-             ; desc (af "err") (atom (output_path state process `Stderr))
-             ; desc (af "pid") (af "%d" lwt#pid) ])))
-
-let unix_status_to_string (p : Unix.process_status) =
-  match p with
-  | Unix.WEXITED i -> sprintf "exited:%d" i
-  | Unix.WSIGNALED i -> sprintf "signaled:%d" i
-  | Unix.WSTOPPED i -> sprintf "stopped:%d" i
-
-let ef_lwt_state =
-  let open Lwt_process in
-  function
-  | Running -> EF.af "Running" | Exited p -> EF.atom (unix_status_to_string p)
-
-let ef ?(all = false) state =
-  EF.(
-    let all_procs =
-      Caml.Hashtbl.fold
-        (fun _ {process; lwt} prev ->
-          match (all, lwt#state) with
-          | true, _ | false, Lwt_process.Running ->
-              ( process.id
-              , list ~delimiters:("{", "}")
-                  [ haf "%s:" process.id
-                  ; desc (af "pid:") (af "%d" lwt#pid)
-                  ; desc (af "state:") (ef_lwt_state lwt#state)
-                  ; desc (af "kind:")
-                      ( match process.kind with
-                      | `Docker n -> af "docker:%s" n
-                      | `Process_group -> af "process-group"
-                      | `Process_group_script _ -> af "shell-script" ) ] )
-              :: prev
-          | _, _ -> prev)
-        (State.processes state) []
-      |> List.sort ~compare:(fun (a, _) (b, _) -> String.compare a b)
-      |> List.map ~f:snd in
-    label (af "Processes:") (list all_procs))
-
-let start t process =
-  let date =
-    Tezos_base.Time.System.now () |> Tezos_base.Time.System.to_notation
-  in
-  let open_file f =
-    System_error.catch
-      ~attach:[("open_file", `String_value f)]
-      Lwt.Infix.(
-        fun () ->
-          Tezos_stdlib_unix.Lwt_utils_unix.create_dir ~perm:0o700
-            (Caml.Filename.dirname f)
-          >>= fun () ->
-          Lwt_unix.file_exists f
-          >>= fun exists ->
-          ( if exists then Lwt_unix.rename f (sprintf "%s.saved-%s" f date)
-          else Lwt.return () )
-          >>= fun () ->
-          Lwt_unix.(
-            openfile f [O_CREAT; O_WRONLY; O_APPEND] 0o600 >|= unix_file_descr))
-      () in
-  open_file (output_path t process `Stdout)
-  >>= fun stdout ->
-  open_file (output_path t process `Stderr)
-  >>= fun stderr ->
-  ( match process.kind with
-  | `Process_group | `Docker _ -> return process.command
-  | `Process_group_script s ->
-      let path = output_path t process `Script in
-      System.write_file t path ~content:s
-      >>= fun () -> return (process.command @ [path]) )
-  >>= fun actual_command ->
-  System_error.catch
-    (fun () ->
-      Lwt_io.with_file ~mode:Lwt_io.output
-        ~flags:Unix.[O_CREAT; O_WRONLY; O_APPEND]
-        (output_path t process `Meta)
-        (fun chan ->
-          let msg =
-            let sep = String.make 80 '=' in
-            sprintf "\n%s\nDate: %s\nStarting: %s\nCmd: [%s]\n%s\n" sep date
-              process.Process.id
-              ( List.map actual_command ~f:(sprintf "%S")
-              |> String.concat ~sep:"; " )
-              sep in
-          Lwt_io.write chan msg))
-    ()
-  >>= fun () ->
-  let proc =
-    Lwt_process.open_process_none ~stdout:(`FD_move stdout)
-      ~stderr:(`FD_move stderr)
-      (Option.value ~default:"" process.binary, Array.of_list actual_command)
-  in
-  State.add_process t process proc >>= fun () -> return {process; lwt= proc}
-
-let start_full t process =
-  let proc_full =
-    Lwt_process.open_process_full
-      (Option.value ~default:"" process.binary, Array.of_list process.command)
-  in
-  let proc = (proc_full :> Lwt_process.process_none) in
-  State.add_process t process proc
-  >>= fun () ->
-  return {process; lwt= proc}
-  >>= fun proc_state -> return (proc_state, proc_full)
-
-let wait _t {lwt; _} =
-  System_error.catch (fun () -> lwt#close) () >>= fun _status -> return _status
-
-let kill _t {lwt; process} =
-  match process.kind with
-  | `Process_group | `Process_group_script _ ->
-      System_error.catch
-        (fun () ->
-          Dbg.e EF.(wf "Killing %S" process.id) ;
-          let signal = Caml.Sys.sigkill in
-          let pid = ~-(lwt#pid) (* Assumes “in session” *) in
-          ( try Unix.kill pid signal with
-          | Unix.Unix_error (Unix.ESRCH, _, _) -> ()
-          | e -> raise e ) ;
-          Lwt.return ())
-        ()
-  | `Docker name -> (
-      System_error.catch Lwt_unix.system (sprintf "docker kill %s" name)
-      >>= fun status ->
-      match status with
-      | Lwt_unix.WEXITED 0 -> return ()
-      | other ->
-          (* Likely already dead *)
-          Dbg.e
-            EF.(
-              desc
-                (shout "docker kill failed")
-                (list
-                   [ af "docker-container: %s" name
-                   ; af "status: %s" (unix_status_to_string other) ])) ;
-          return () )
-
-let wait_all t =
-  State.all_processes t
-  >>= fun all ->
-  List.fold all ~init:(return ()) ~f:(fun prevm one ->
-      prevm >>= fun () -> wait t one >>= fun _ -> return ())
-
-let kill_all t =
-  State.all_processes t
-  >>= fun all ->
-  List.fold all ~init:(return ()) ~f:(fun prevm one ->
-      prevm >>= fun () -> kill t one)
-
-let find_process_by_id ?(only_running = false) t ~f =
-  State.all_processes t
-  >>= fun all ->
-  return
-    (List.filter all ~f:(fun {process= {id; _}; lwt} ->
-         if only_running && not Poly.(lwt#state = Lwt_process.Running) then
-           false
-         else f id))
-
-let cmds = ref 0
-
-let fresh_id _state prefix ~seed =
-  Caml.incr cmds ;
-  sprintf "%s-%05d-%s-%08d" prefix !cmds
-    Caml.Digest.(string seed |> to_hex)
-    Random.(int 10_000_000)
-
-let run_cmdf ?(id_prefix = "cmd") state fmt =
-  let get_file path =
-    System_error.catch
-      Lwt.(
-        fun () ->
-          Lwt_io.open_file ~mode:Lwt_io.input path
-          >>= fun inchan ->
-          let stream = Lwt_io.read_lines inchan in
-          Lwt_stream.to_list stream
-          >>= fun l -> Lwt_io.close inchan >>= fun () -> return l)
-      () in
-  ksprintf
-    (fun s ->
-      let id = fresh_id state id_prefix ~seed:s in
-      let proc = Process.make_in_session id `Process_group ["sh"; "-c"; s] in
-      start state proc
-      >>= fun proc ->
-      wait state proc
-      >>= fun status ->
-      get_file (output_path state proc.process `Stdout)
-      >>= fun out_lines ->
-      get_file (output_path state proc.process `Stderr)
-      >>= fun err_lines ->
-      return
-        (object
-           method out = out_lines
-
-           method err = err_lines
-
-           method status = status
-        end))
-    fmt
-
-let run_successful_cmdf state fmt =
-  ksprintf
-    (fun cmd ->
-      run_cmdf state "%s" cmd
-      >>= fun res ->
-      Process_result.Error.fail_if_non_zero res
-        (sprintf "Shell command: %S" cmd)
-      >>= fun () -> return res)
-    fmt
-
-let run_genspio state name genspio =
-  let proc = Process.genspio (fresh_id state name ~seed:name) genspio in
-  start state proc >>= fun proc -> wait state proc
-
-module Async = struct
-  let run_cmdf ?(id_base = "async-cmd") state ~f fmt =
-    ksprintf
-      (fun s ->
-        let id = fresh_id state id_base ~seed:s in
-        let proc = Process.make_in_session id `Process_group ["sh"; "-c"; s] in
-        start_full state proc
-        >>= fun (proc_state, proc) ->
-        Dbg.e EF.(wf "Started async: %S" proc_state.process.id) ;
-        f proc_state proc
-        >>= fun res ->
-        wait state proc_state >>= fun status -> return (status, res))
-      fmt
-
-  let fold_process (process : Lwt_process.process_full) ~init ~f =
-    let out = Lwt_io.read_chars process#stdout in
-    let err = Lwt_io.read_chars process#stderr in
-    let rec go prev_m () =
-      prev_m
-      >>= fun prev ->
-      match (Lwt_stream.get_available out, Lwt_stream.get_available err) with
-      | [], [] -> (
-          System_error.catch Lwt.choose
-            Lwt.
-              [ (Lwt_stream.peek out >>= fun x -> return (`Left x))
-              ; (Lwt_stream.peek err >>= fun x -> return (`Right x)) ]
-          >>= function
-          | `Left None -> (
-              System_error.catch Lwt_stream.peek err
-              >>= function
-              | None -> return prev | Some _ -> go (return prev) () )
-          | `Right None -> (
-              System_error.catch Lwt_stream.peek out
-              >>= function
-              | None -> return prev | Some _ -> go (return prev) () )
-          | _ -> go (return prev) () )
-      | outl, errl -> (
-          f prev (String.of_char_list outl) (String.of_char_list errl)
-          >>= function
-          | `Done n -> return n | `Continue next -> go (return next) () ) in
-    go (return init) ()
-end
diff --git a/vendors/flextesa-lib/running_processes.mli b/vendors/flextesa-lib/running_processes.mli
deleted file mode 100644
index 4286a2a26c7dd22db64473618059cebc08e5cd01..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/running_processes.mli
+++ /dev/null
@@ -1,123 +0,0 @@
-(** Run and monitor processes. *)
-
-open Internal_pervasives
-
-(** The definition of a process, for now, a process within a
-    process-group or a Docker container. *)
-module Process : sig
-  type kind =
-    [`Process_group | `Docker of string | `Process_group_script of string]
-
-  type t = private
-    {id: string; binary: string option; command: string list; kind: kind}
-
-  val make_in_session : ?binary:string -> string -> kind -> string list -> t
-  val genspio : string -> 'a Genspio.EDSL.t -> t
-
-  val docker_run :
-    string -> image:string -> options:string list -> args:string list -> t
-end
-
-(** The container for a list of running or not processes. *)
-module State : sig
-  type process_state = private
-    {process: Process.t; lwt: Lwt_process.process_none}
-
-  type t = private {processes: (string, process_state) Caml.Hashtbl.t}
-
-  val pp : t Fmt.t
-  val make : unit -> t
-end
-
-val output_path :
-  < paths: Paths.t ; .. > -> Process.t -> [`Meta | `Stderr | `Stdout] -> string
-(** Return the path (within {!Paths}'s root-path) where the process
-    writes its output or metadata. *)
-
-val ef_processes :
-  < paths: Paths.t ; .. > -> State.process_state list -> Easy_format.t
-
-val ef : ?all:bool -> < runner: State.t ; .. > -> Easy_format.t
-
-val start :
-     < application_name: string ; paths: Paths.t ; runner: State.t ; .. >
-  -> Process.t
-  -> (State.process_state, [> System_error.t]) Asynchronous_result.t
-
-val wait :
-     < runner: State.t ; .. >
-  -> State.process_state
-  -> (Lwt_unix.process_status, [> System_error.t]) Asynchronous_result.t
-
-val kill :
-     < runner: State.t ; .. >
-  -> State.process_state
-  -> (unit, [> System_error.t]) Asynchronous_result.t
-
-val wait_all :
-  < runner: State.t ; .. > -> (unit, [> System_error.t]) Asynchronous_result.t
-
-val kill_all :
-  < runner: State.t ; .. > -> (unit, [> System_error.t]) Asynchronous_result.t
-
-val find_process_by_id :
-     ?only_running:bool
-  -> < runner: State.t ; .. >
-  -> f:(string -> bool)
-  -> (State.process_state list, [> ]) Asynchronous_result.t
-
-val run_cmdf :
-     ?id_prefix:string
-  -> < paths: Paths.t ; runner: State.t ; .. > Base_state.t
-  -> ( 'a
-     , unit
-     , string
-     , (Process_result.t, [> System_error.t]) Asynchronous_result.t )
-     format4
-  -> 'a
-(** Run a shell command and wait for its end. *)
-
-val run_successful_cmdf :
-     < paths: Paths.t ; runner: State.t ; .. > Base_state.t
-  -> ( 'a
-     , unit
-     , string
-     , ( Process_result.t
-       , [> System_error.t | Process_result.Error.t] )
-       Asynchronous_result.t )
-     format4
-  -> 'a
-
-val run_genspio :
-     < paths: Paths.t ; runner: State.t ; .. > Base_state.t
-  -> string
-  -> 'a Genspio.Language.t
-  -> (Lwt_unix.process_status, [> System_error.t]) Asynchronous_result.t
-
-module Async : sig
-  val run_cmdf :
-       ?id_base:string
-    -> < runner: State.t ; .. >
-    -> f:(   State.process_state
-          -> Lwt_process.process_full
-          -> ('return_ok, ([> System_error.t] as 'error)) Asynchronous_result.t)
-    -> ( 'c
-       , unit
-       , string
-       , (Unix.process_status * 'return_ok, 'error) Asynchronous_result.t )
-       format4
-    -> 'c
-  (** Run a shell command and run a function over the process data before waiting for its end. *)
-
-  val fold_process :
-       Lwt_process.process_full
-    -> init:'a
-    -> f:(   'a
-          -> string
-          -> string
-          -> ( [< `Continue of 'a | `Done of 'a]
-             , ([> System_error.t] as 'b) )
-             Asynchronous_result.t)
-    -> ('a, 'b) Asynchronous_result.t
-  (** Fold over the output and error-output of a {!Lwt_process.process_full}, and  *)
-end
diff --git a/vendors/flextesa-lib/test_api.ml b/vendors/flextesa-lib/test_api.ml
deleted file mode 100644
index 5787eb091c72053224e4ec88ef9d8a1f6fbf5d94..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/test_api.ml
+++ /dev/null
@@ -1,108 +0,0 @@
-open Internal_pervasives
-module IFmt = More_fmt
-
-let failf ?attach fmt =
-  ksprintf (fun s -> fail ?attach (`Scenario_error s)) fmt
-
-type display_policy = [`All | `Lines of int | `No | `On_error of display_policy]
-
-let call ?comment ?(expect = `Status `OK) ?(show_body = `All)
-    ?(show_response = `On_error `All) ?(how = `Get) state ~api_prefix ~path =
-  let http_method, body =
-    let json_body json =
-      Some (Cohttp_lwt.Body.of_string (Ezjsonm.to_string ~minify:false json))
-    in
-    match how with
-    | `Get -> (`GET, None)
-    | `Post_json json -> (`POST, json_body json)
-    | `Delete_json json -> (`DELETE, json_body json) in
-  let make_body b =
-    let json =
-      try Ok (Ezjsonm.value_from_string b) with
-      | Ezjsonm.Parse_error (_, s) -> Error (sprintf "Error: %s" s)
-      | e -> Error (sprintf "???: %s" (Exn.to_string e)) in
-    let lines =
-      String.split_lines
-        ( match json with
-        | Ok j -> Ezjsonm.value_to_string ~minify:false j
-        | Error _ -> b ) in
-    (json, lines) in
-  System_error.catch
-    Lwt.(
-      fun () ->
-        Cohttp_lwt_unix.Client.call http_method ?body
-          ~headers:(Cohttp.Header.init_with "content-type" "application/json")
-          (Uri.of_string (api_prefix // path))
-        >>= fun (r, bod) ->
-        Cohttp_lwt.Body.to_string bod >>= fun bl -> return (r, make_body bl))
-    ()
-  >>= fun (coresp, cobody) ->
-  ( match expect with
-  | `Status status when Poly.equal (Cohttp.Response.status coresp) status ->
-      return `Ok
-  | `Status status ->
-      return
-        (`Failed
-          (sprintf "API call %s did not return `%s` but `%s`" path
-             (Cohttp.Code.string_of_status status)
-             (Cohttp.Response.status coresp |> Cohttp.Code.string_of_status)))
-  | `Anything -> return `Ok )
-  >>= fun test_status ->
-  Console.sayf state
-    IFmt.(
-      let pp_body ?just_lines ppf (json, lines) =
-        cut ppf () ;
-        pf ppf "* Body (%d lines, %s)" (List.length lines)
-          (match json with Ok _ -> "valid JSON" | Error s -> s) ;
-        if List.length lines > 0 then (
-          pf ppf ":" ;
-          cut ppf () ;
-          vertical_box ppf ~indent:0 (fun ppf ->
-              cut ppf () ;
-              string ppf (String.make 60 '`') ;
-              List.iter
-                ( match just_lines with
-                | None -> lines
-                | Some n -> List.take lines n )
-                ~f:(fun l -> cut ppf () ; string ppf l) ;
-              ( match just_lines with
-              | Some n when n < List.length lines ->
-                  cut ppf () ; string ppf "° ° °"
-              | _ -> () ) ;
-              cut ppf () ;
-              string ppf (String.make 60 '`')) ) in
-      let pp_response ppf () =
-        cut ppf () ;
-        pf ppf "* Response:" ;
-        cut ppf () ;
-        Sexplib0.Sexp.pp_hum_indent 4 ppf (Cohttp.Response.sexp_of_t coresp)
-      in
-      let rec un_option_show f = function
-        | `On_error _ when Poly.equal test_status `Ok -> ()
-        | `On_error l -> un_option_show f l
-        | `No -> ()
-        | `All -> f None
-        | `Lines l -> f (Some l) in
-      fun ppf () ->
-        vertical_box ppf (fun ppf ->
-            pf ppf "# Called %s /%s → %s `%s`:"
-              (Cohttp.Code.string_of_method http_method)
-              path
-              (if Poly.equal test_status `Ok then "Expected" else "UNEXPECTED")
-              (Cohttp.Response.status coresp |> Cohttp.Code.string_of_status) ;
-            Option.iter comment ~f:(fun c ->
-                cut ppf () ; string ppf "* " ; c ppf) ;
-            un_option_show (fun _ -> pp_response ppf ()) show_response ;
-            un_option_show
-              (fun just_lines -> pp_body ?just_lines ppf cobody)
-              show_body))
-  >>= fun () ->
-  match test_status with
-  | `Ok ->
-      return
-        (object
-           method body_lines = snd cobody
-
-           method body_json = fst cobody
-        end)
-  | `Failed s -> failf "%s" s
diff --git a/vendors/flextesa-lib/test_api.mli b/vendors/flextesa-lib/test_api.mli
deleted file mode 100644
index a1f73ff0840daf8f9f4c77cc34a7901e2a24241e..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/test_api.mli
+++ /dev/null
@@ -1,18 +0,0 @@
-(** Test APIs by hitting endpoints. *)
-
-open Internal_pervasives
-
-type display_policy = [`All | `Lines of int | `No | `On_error of display_policy]
-
-val call :
-     ?comment:(Caml.Format.formatter -> unit)
-  -> ?expect:[< `Anything | `Status of Cohttp.Code.status_code > `Status]
-  -> ?show_body:display_policy
-  -> ?show_response:display_policy
-  -> ?how:[`Get | `Post_json of Ezjsonm.t | `Delete_json of Ezjsonm.t]
-  -> < console: Console.t ; .. > Base_state.t
-  -> api_prefix:string
-  -> path:string
-  -> ( < body_json: (Ezjsonm.value, string) Result.t ; body_lines: string list >
-     , [> System_error.t | `Scenario_error of string] )
-     Asynchronous_result.t
diff --git a/vendors/flextesa-lib/test_command_line.ml b/vendors/flextesa-lib/test_command_line.ml
deleted file mode 100644
index c067f4f4d6e45da2ba40d8469cbd4f50f3759a15..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/test_command_line.ml
+++ /dev/null
@@ -1,122 +0,0 @@
-open Internal_pervasives
-
-module Command_making_state = struct
-  type specific =
-    < env_config: Environment_configuration.t
-    ; command_name: string
-    ; manpager: Manpage_builder.State.t >
-
-  type 'a t = 'a Base_state.t constraint 'a = < specific ; .. >
-
-  let make ~application_name ~command_name () : _ t =
-    let env_config = Environment_configuration.default () in
-    let manpager = Manpage_builder.State.make () in
-    Environment_configuration.init
-      (object
-         method manpager = manpager
-      end)
-      env_config ;
-    object
-      method application_name = application_name
-
-      method command_name = command_name
-
-      method env_config = env_config
-
-      method manpager = manpager
-    end
-end
-
-module Common_errors = struct
-  type t =
-    [ `Die of int
-    | `Empty_protocol_list
-    | `Precheck_failure of string
-    | Process_result.Error.t
-    | `Scenario_error of string
-    | System_error.t
-    | Test_scenario.Inconsistency_error.t
-    | `Waiting_for of string * [`Time_out] ]
-
-  let pp ppf (e : t) =
-    match e with
-    | `Scenario_error s -> Caml.Format.fprintf ppf "%s" s
-    | #Test_scenario.Inconsistency_error.t as e ->
-        Caml.Format.fprintf ppf "%a" Test_scenario.Inconsistency_error.pp e
-    | #Process_result.Error.t as e ->
-        Caml.Format.fprintf ppf "%a" Process_result.Error.pp e
-    | #System_error.t as e -> Caml.Format.fprintf ppf "%a" System_error.pp e
-    | `Waiting_for (msg, `Time_out) ->
-        Caml.Format.fprintf ppf "WAITING-FOR “%s”: Time-out" msg
-    | `Precheck_failure _ as p -> Helpers.System_dependencies.Error.pp ppf p
-    | `Die n -> Caml.Format.fprintf ppf "Exiting with %d" n
-end
-
-module Run_command = struct
-  let or_hard_fail state main ~pp_error : unit =
-    let open Asynchronous_result in
-    Dbg.e EF.(wf "Run_command.or_hard_fail") ;
-    run_application (fun () ->
-        Dbg.e EF.(wf "Run_command.or_hard_fail bind_on_error") ;
-        bind_on_error (main ()) ~f:(fun ~result _ ->
-            Dbg.e EF.(wf "Run_command.or_hard_fail on result") ;
-            transform_error
-              ~f:(fun _ -> `Die 3)
-              (Console.say state
-                 EF.(
-                   custom (fun ppf -> Attached_result.pp ppf result ~pp_error)))
-            >>= fun () -> die 2)
-        >>= fun () ->
-        Dbg.e EF.(wf "Run_command.or_hard_fail after bind_on_error") ;
-        return ())
-
-  let term ~pp_error () =
-    Cmdliner.Term.pure (fun (state, run) -> or_hard_fail state run ~pp_error)
-
-  let make ~pp_error t (i : Cmdliner.Cmd.info) =
-    Cmdliner.Term.(term ~pp_error () $ t, i)
-end
-
-module Full_default_state = struct
-  let cmdliner_term base_state ?default_interactivity
-      ?(disable_interactivity = false) () =
-    let runner = Running_processes.State.make () in
-    let default_root = sprintf "/tmp/%s-test" base_state#command_name in
-    let pauser = Interactive_test.Pauser.make [] in
-    let ops = Log_recorder.Operations.make () in
-    let state console paths interactivity =
-      object
-        method paths = paths
-
-        method runner = runner
-
-        method console = console
-
-        method application_name = base_state#application_name
-
-        method test_interactivity = interactivity
-
-        method pauser = pauser
-
-        method operations_log = ops
-
-        method env_config = base_state#env_config
-      end in
-    let open Cmdliner in
-    Term.(
-      pure state $ Console.cli_term ()
-      $ Paths.cli_term ~default_root ()
-      $
-      if disable_interactivity then pure `None
-      else
-        Interactive_test.Interactivity.cli_term ?default:default_interactivity
-          ())
-end
-
-let cli_state ?default_interactivity ?disable_interactivity ~name () =
-  let application_name = Fmt.str "Flextesa.%s" name in
-  let command_name = name in
-  let base_state =
-    Command_making_state.make ~application_name ~command_name () in
-  Full_default_state.cmdliner_term base_state ?default_interactivity
-    ?disable_interactivity ()
diff --git a/vendors/flextesa-lib/test_command_line.mli b/vendors/flextesa-lib/test_command_line.mli
deleted file mode 100644
index 009b9c652b6899fb3398ff7eebca135ff4001f32..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/test_command_line.mli
+++ /dev/null
@@ -1,86 +0,0 @@
-(** Functions for building test-scenarios commands. *)
-
-open Internal_pervasives
-
-module Common_errors : sig
-  type t =
-    [ `Die of int
-    | `Empty_protocol_list
-    | `Precheck_failure of string
-    | Process_result.Error.t
-    | `Scenario_error of string
-    | System_error.t
-    | Test_scenario.Inconsistency_error.t
-    | `Waiting_for of string * [`Time_out] ]
-
-  val pp : t Fmt.t
-end
-
-module Command_making_state : sig
-  type specific =
-    < command_name: string
-    ; env_config: Environment_configuration.t
-    ; manpager: Manpage_builder.State.t >
-
-  type 'a t = 'a constraint 'a = < application_name: string ; specific ; .. >
-
-  val make :
-       application_name:string
-    -> command_name:string
-    -> unit
-    -> < application_name: string
-       ; command_name: string
-       ; env_config: Environment_configuration.t
-       ; manpager: Manpage_builder.State.t >
-end
-
-(** Make {!Cmdliner} commands from {!Asynchronous_result} functions. *)
-module Run_command : sig
-  val or_hard_fail :
-       < application_name: string ; console: Console.t ; .. >
-    -> (unit -> (unit, ([> ] as 'a)) Asynchronous_result.t)
-    -> pp_error:(Caml.Format.formatter -> 'a -> unit)
-    -> unit
-
-  val make :
-       pp_error:(Caml.Format.formatter -> ([> ] as 'errors) -> unit)
-    -> ( < application_name: string ; console: Console.t ; .. >
-       * (unit -> (unit, 'errors) Asynchronous_result.t) )
-       Cmdliner.Term.t
-    -> Cmdliner.Cmd.info
-    -> unit Cmdliner.Term.t * Cmdliner.Cmd.info
-end
-
-module Full_default_state : sig
-  val cmdliner_term :
-       _ Command_making_state.t
-    -> ?default_interactivity:Interactive_test.Interactivity.t
-    -> ?disable_interactivity:bool
-    -> unit
-    -> < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; operations_log: Log_recorder.Operations.t
-       ; paths: Paths.t
-       ; pauser: Interactive_test.Pauser.t
-       ; runner: Running_processes.State.t
-       ; test_interactivity: Interactive_test.Interactivity.t >
-       Cmdliner.Term.t
-end
-
-(** Legacy API for {!Full_default_state.cmdliner_term}. *)
-val cli_state :
-     ?default_interactivity:Interactive_test.Interactivity.t
-  -> ?disable_interactivity:bool
-  -> name:string
-  -> unit
-  -> < application_name: string
-     ; env_config: Environment_configuration.t
-     ; console: Console.t
-     ; operations_log: Log_recorder.Operations.t
-     ; paths: Paths.t
-     ; pauser: Interactive_test.Pauser.t
-     ; runner: Running_processes.State.t
-     ; test_interactivity: Interactive_test.Interactivity.t >
-     Cmdliner.Term.t
-(** Create a full [state] value for test-scenarios. *)
diff --git a/vendors/flextesa-lib/test_scenario.ml b/vendors/flextesa-lib/test_scenario.ml
deleted file mode 100644
index bd548cf2a2f9607b05a166d47142cacdd2ecf933..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/test_scenario.ml
+++ /dev/null
@@ -1,307 +0,0 @@
-open Internal_pervasives
-
-module Inconsistency_error = struct
-  type t =
-    [ `Empty_protocol_list
-    | `Too_many_protocols of Tezos_protocol.t list
-    | `Too_many_timestamp_delays of Tezos_protocol.t list ]
-
-  let should_be_one_protocol = function
-    | [one] -> return one
-    | [] -> fail `Empty_protocol_list
-    | more -> fail (`Too_many_protocols more)
-
-  let should_be_one_timestamp_delay = function
-    | [_] -> return ()
-    | [] -> fail `Empty_protocol_list
-    | more -> fail (`Too_many_timestamp_delays more)
-
-  let pp fmt err =
-    match err with
-    | `Empty_protocol_list ->
-        Caml.Format.fprintf fmt "Wrong number of protocols in network: 0"
-    | `Too_many_protocols p ->
-        Caml.Format.fprintf fmt "Wrong number of protocols in network: %d"
-          (List.length p)
-    | `Too_many_timestamp_delays p ->
-        Caml.Format.fprintf fmt
-          "Wrong number of protocol timestamp delays in network: %d"
-          (List.length p)
-end
-
-module Topology = struct
-  type node = Tezos_node.t
-
-  type _ t =
-    | Mesh : {size: int} -> node list t
-    | Bottleneck :
-        {name: string; left: 'a network; right: 'b network}
-        -> ('a * node * 'b) t
-    | Net_in_the_middle :
-        {middle: 'm network; left: 'a network; right: 'b network}
-        -> ('a * 'm * 'b) t
-
-  and 'a network = {topology: 'a t; name: string}
-
-  let make name topology = {name; topology}
-  let mesh name size = Mesh {size} |> make name
-  let sub = make
-  let bottleneck name left right = Bottleneck {name; left; right} |> make name
-
-  let net_in_the_middle name middle left right =
-    Net_in_the_middle {middle; left; right} |> make name
-
-  let rec node_count : type a. a t -> int = function
-    | Mesh {size} -> size
-    | Bottleneck {left; right; _} ->
-        1 + node_count left.topology + node_count right.topology
-    | Net_in_the_middle {left; right; middle} ->
-        node_count middle.topology + node_count left.topology
-        + node_count right.topology
-
-  let rec node_ids : type a. a t -> a -> string list =
-   fun topo res ->
-    match (topo, res) with
-    | Mesh _, l -> List.map l ~f:(fun nod -> nod.Tezos_node.id)
-    | Bottleneck {left; right; _}, (l, i, r) ->
-        (i.Tezos_node.id :: node_ids left.topology l)
-        @ node_ids right.topology r
-    | Net_in_the_middle {left; right; middle}, (l, i, r) ->
-        node_ids middle.topology i @ node_ids left.topology l
-        @ node_ids right.topology r
-
-  let rec node_names : type a. ?prefix:string -> a network -> string list =
-   fun ?(prefix = "") {name; topology} ->
-    let make_ith i = sprintf "%s%03d" prefix i in
-    let continue a = node_names ~prefix:(prefix ^ name) a in
-    match topology with
-    | Mesh {size} -> List.init size ~f:make_ith
-    | Bottleneck {name; left; right} ->
-        (sprintf "%s%s" prefix name :: continue left) @ continue right
-    | Net_in_the_middle {left; right; middle} ->
-        continue middle @ continue left @ continue right
-
-  let build ?(external_peer_ports = []) ?(base_port = 15_001) ~make_node
-      network =
-    let all_ports = ref [] in
-    let next_port = ref (base_port + Int.rem base_port 2) in
-    let rpc name =
-      match List.find !all_ports ~f:(fun (n, _) -> String.equal n name) with
-      | Some (_, p) -> p
-      | None ->
-          let p = !next_port in
-          all_ports := (name, p) :: !all_ports ;
-          next_port := !next_port + 2 ;
-          p in
-    let p2p n = rpc n + 1 in
-    let node peers id =
-      let rpc_port = rpc id in
-      let p2p_port = p2p id in
-      let expected_connections =
-        List.length peers + List.length external_peer_ports in
-      let peers =
-        List.filter_map peers ~f:(fun p ->
-            if not (String.equal p id) then Some (p2p p) else None) in
-      make_node id ~expected_connections ~rpc_port ~p2p_port
-        (external_peer_ports @ peers) in
-    let dbgp prefx names =
-      Dbg.f (fun pf ->
-          pf "%s:\n  %s\n%!" prefx
-            (String.concat ~sep:"\n  "
-               (List.map names ~f:(fun n -> sprintf "%s:%d" n (p2p n))))) in
-    let rec make :
-        type a. ?extra_peers:string list -> prefix:string -> a network -> a =
-     fun ?(extra_peers = []) ~prefix network ->
-      let prefix = prefix ^ network.name in
-      let make ?extra_peers n = make ?extra_peers ~prefix n in
-      match network.topology with
-      | Bottleneck {name; left; right} ->
-          let intermediate = name in
-          let extra_peers = [intermediate] in
-          let left_nodes = make ~extra_peers left in
-          let right_nodes = make ~extra_peers right in
-          let intermediate_node =
-            let peers =
-              node_ids left.topology left_nodes
-              @ node_ids right.topology right_nodes in
-            node peers intermediate in
-          (left_nodes, intermediate_node, right_nodes)
-      | Net_in_the_middle {middle; left; right} ->
-          let middle_names = node_names ~prefix:(prefix ^ middle.name) middle in
-          dbgp "Mid-name" middle_names ;
-          let left_nodes =
-            make ~extra_peers:(extra_peers @ middle_names) left in
-          let right_nodes =
-            make ~extra_peers:(extra_peers @ middle_names) right in
-          let intermediate_nodes =
-            let peers =
-              node_ids left.topology left_nodes
-              @ node_ids right.topology right_nodes in
-            dbgp "peers" peers ;
-            dbgp "extr-peers" extra_peers ;
-            dbgp "left-names" (node_names ~prefix:(prefix ^ left.name) left) ;
-            dbgp "right-names" (node_names ~prefix:(prefix ^ right.name) right) ;
-            make ~extra_peers:(peers @ extra_peers) middle in
-          (left_nodes, intermediate_nodes, right_nodes)
-      | Mesh _ ->
-          let all = node_names ~prefix network in
-          dbgp "mesh-names" all ;
-          let nodes = List.map all ~f:(fun n -> node (all @ extra_peers) n) in
-          nodes in
-    make ~prefix:"" network
-end
-
-module Queries = struct
-  let all_levels ?(chain = "main") state ~nodes =
-    List.fold nodes ~init:(return [])
-      ~f:(fun prevm {Tezos_node.id; rpc_port; _} ->
-        prevm
-        >>= fun prev ->
-        Running_processes.run_cmdf state
-          (* the header RPC is the most consistent across protocols: *)
-          "curl http://localhost:%d/chains/%s/blocks/head/header" rpc_port
-          chain
-        >>= fun metadata ->
-        Console.display_errors_of_command state metadata ~should_output:true
-        >>= (function
-              | true -> (
-                try
-                  `Level
-                    ( Jqo.of_lines metadata#out |> Jqo.field ~k:"level"
-                    |> Jqo.get_int )
-                  |> return
-                with _ -> return `Failed )
-              | false -> return `Failed)
-        >>= fun res -> return ((id, res) :: prev))
-    >>= fun results ->
-    let sorted =
-      List.sort results ~compare:(fun (a, _) (b, _) -> String.compare a b)
-    in
-    return sorted
-
-  let wait_for_all_levels_to_be ?attempts_factor ?chain state ~attempts
-      ~seconds nodes level =
-    let check_level =
-      match level with
-      | `Equal_to l -> ( = ) l
-      | `At_least l -> fun x -> x >= l in
-    let level_string =
-      match level with
-      | `Equal_to l -> sprintf "= %d" l
-      | `At_least l -> sprintf "≥ %d" l in
-    let msg ids =
-      let show_node (id, res) =
-        sprintf "%s (%s)" id
-          ( match res with
-          | `Failed -> "failed"
-          | `Level l -> sprintf "%d" l
-          | `Null -> "null"
-          | `Unknown s -> sprintf "¿¿ %S ??" s ) in
-      sprintf "Waiting for %s to reach level %s"
-        (String.concat (List.map ~f:show_node ids) ~sep:", ")
-        level_string in
-    Console.say state
-      EF.(
-        wf "Checking for all levels to be %s (nodes: %s%s)" level_string
-          (String.concat ~sep:", "
-             (List.map nodes ~f:(fun n -> n.Tezos_node.id)))
-          (Option.value_map chain ~default:"" ~f:(sprintf ", chain: %s")))
-    >>= fun () ->
-    Helpers.wait_for state ?attempts_factor ~attempts ~seconds (fun _nth ->
-        all_levels state ~nodes ?chain
-        >>= fun results ->
-        let not_readys =
-          List.filter_map results ~f:(function
-            | _, `Level n when check_level n -> None
-            | id, res -> Some (id, res)) in
-        match not_readys with
-        | [] -> return (`Done ())
-        | ids -> return (`Not_done (msg ids)))
-end
-
-module Network = struct
-  type t = {nodes: Tezos_node.t list}
-
-  let make nodes = {nodes}
-
-  let start_up ?(do_activation = true) ?(check_ports = true) state ~client_exec
-      {nodes} =
-    ( if check_ports then
-      Helpers.Netstat.used_listening_ports state
-      >>= fun all_used ->
-      let taken port = List.find all_used ~f:(fun (p, _) -> Int.equal p port) in
-      List_sequential.iter nodes
-        ~f:(fun {Tezos_node.id; rpc_port; p2p_port; _} ->
-          let fail s (p, `Tcp (_, row)) =
-            System_error.fail_fatalf
-              "Node: %S's %s port %d already in use {%s}" id s p
-              (String.concat ~sep:"|" row) in
-          let time_wait (_, `Tcp (_, row)) =
-            Poly.equal (List.last row) (Some "TIME_WAIT") in
-          match (taken rpc_port, taken p2p_port) with
-          | None, None -> return ()
-          | Some p, _ -> if time_wait p then return () else fail "RPC" p
-          | _, Some p -> if time_wait p then return () else fail "P2P" p)
-    else return () )
-    >>= fun () ->
-    let protocols =
-      List.map ~f:Tezos_node.protocol nodes
-      |> List.dedup_and_sort ~compare:Tezos_protocol.compare in
-    Inconsistency_error.should_be_one_protocol protocols
-    >>= fun protocol ->
-    Inconsistency_error.should_be_one_timestamp_delay protocols
-    >>= fun () ->
-    Tezos_protocol.ensure state protocol
-    >>= fun () ->
-    List.fold nodes ~init:(return ()) ~f:(fun prev_m node ->
-        prev_m
-        >>= fun () ->
-        Running_processes.start state (Tezos_node.process state node)
-        >>= fun _ -> return ())
-    >>= fun () ->
-    let node_0 = List.hd_exn nodes in
-    let client = Tezos_client.of_node node_0 ~exec:client_exec in
-    Dbg.e EF.(af "Trying to bootstrap client") ;
-    Tezos_client.wait_for_node_bootstrap state client
-    >>= fun () ->
-    Tezos_client.rpc state ~client `Get ~path:"/chains/main/blocks/head/header"
-    >>= fun json ->
-    let do_activation =
-      (* If the level is 0 we still do the activation. *)
-      do_activation
-      ||
-      try Int.equal Jqo.(field ~k:"level" json |> get_int) 0 with _ -> false
-    in
-    ( if do_activation then Tezos_client.activate_protocol state client protocol
-    else return () )
-    >>= fun () ->
-    Dbg.e EF.(af "Waiting for all nodes to be bootstrapped") ;
-    List_sequential.iter nodes ~f:(fun node ->
-        let client = Tezos_client.of_node node ~exec:client_exec in
-        Tezos_client.wait_for_node_bootstrap state client)
-    >>= fun () ->
-    (* We make sure all nodes got activation before trying to continue: *)
-    Queries.wait_for_all_levels_to_be state ~attempts:20 ~seconds:0.5
-      ~attempts_factor:0.8 nodes (`At_least 1)
-end
-
-let network_with_protocol ?do_activation ?node_custom_network
-    ?external_peer_ports ?base_port ?(size = 5) ?protocol
-    ?(nodes_history_mode_edits = return) state ~node_exec ~client_exec =
-  let pre_edit_nodes =
-    Topology.build ?base_port ?external_peer_ports
-      ~make_node:(fun id ~expected_connections ~rpc_port ~p2p_port peers ->
-        Tezos_node.make ?protocol ~exec:node_exec id ~expected_connections
-          ?custom_network:node_custom_network ~rpc_port ~p2p_port peers)
-      (Topology.mesh "N" size) in
-  nodes_history_mode_edits pre_edit_nodes
-  >>= fun nodes ->
-  let protocols =
-    List.map ~f:Tezos_node.protocol nodes
-    |> List.dedup_and_sort ~compare:Tezos_protocol.compare in
-  Inconsistency_error.should_be_one_protocol protocols
-  >>= fun protocol ->
-  Inconsistency_error.should_be_one_timestamp_delay protocols
-  >>= fun () ->
-  Network.start_up ?do_activation state ~client_exec (Network.make nodes)
-  >>= fun () -> return (nodes, protocol)
diff --git a/vendors/flextesa-lib/test_scenario.mli b/vendors/flextesa-lib/test_scenario.mli
deleted file mode 100644
index 99acf7e03a9caead057b077c7cb872ceca7e6fa2..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/test_scenario.mli
+++ /dev/null
@@ -1,165 +0,0 @@
-(** Build and manage Network Sandboxes. *)
-
-open Internal_pervasives
-
-module Inconsistency_error : sig
-  type t =
-    [ `Empty_protocol_list
-    | `Too_many_protocols of Tezos_protocol.t list
-    | `Too_many_timestamp_delays of Tezos_protocol.t list ]
-
-  val should_be_one_protocol :
-       'a list
-    -> ( 'a
-       , [> `Empty_protocol_list
-         | `Too_many_protocols of 'a list
-         | `Too_many_timestamp_delays of 'a list ] )
-       Asynchronous_result.t
-
-  val pp :
-       Caml.Format.formatter
-    -> [< `Empty_protocol_list
-       | `Too_many_protocols of 'a Base.List.t
-       | `Too_many_timestamp_delays of 'a Base.List.t ]
-    -> unit
-end
-
-(** Build {i static} tezos network topologies. *)
-module Topology : sig
-  type node = Tezos_node.t
-
-  type _ t = private
-    | Mesh : {size: int} -> node list t
-    | Bottleneck :
-        {name: string; left: 'a network; right: 'b network}
-        -> ('a * node * 'b) t
-    | Net_in_the_middle :
-        {middle: 'm network; left: 'a network; right: 'b network}
-        -> ('a * 'm * 'b) t
-
-  and 'a network = {topology: 'a t; name: string}
-
-  val mesh : string -> int -> node list network
-  val sub : string -> 'a t -> 'a network
-
-  val bottleneck :
-    string -> 'a network -> 'b network -> ('a * node * 'b) network
-
-  val node_count : 'a t -> int
-  val node_ids : 'a t -> 'a -> string list
-
-  val net_in_the_middle :
-    string -> 'a network -> 'b network -> 'c network -> ('b * 'a * 'c) network
-
-  val build :
-       ?external_peer_ports:int list
-    -> ?base_port:int
-    -> make_node:(   string
-                  -> expected_connections:int
-                  -> rpc_port:int
-                  -> p2p_port:int
-                  -> int list
-                  -> node)
-    -> 'a network
-    -> 'a
-end
-
-(** Start networks from (and manipulate) {!Topology.t} values. *)
-module Network : sig
-  type t = private {nodes: Tezos_node.t list}
-
-  val make : Tezos_node.t list -> t
-
-  val start_up :
-       ?do_activation:bool
-    -> ?check_ports:bool
-    -> < Base_state.base
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; console: Console.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client_exec:Tezos_executable.t
-    -> t
-    -> ( unit
-       , [> `Empty_protocol_list
-         | System_error.t
-         | Process_result.Error.t
-         | Process_result.Error.t
-         | `Too_many_protocols of Tezos_protocol.t list
-         | `Too_many_timestamp_delays of Tezos_protocol.t list
-         | `Waiting_for of string * [`Time_out] ] )
-       Asynchronous_result.t
-  (** Start the nodes, bootstrap the client, and (potentially)
-      activate the protocol of a network.
-
-      - [?do_activation]: if [true] the start-up will try to activate
-        the protocol, if [false] it will do it only if the current
-        level of the chain is [0].
- *)
-end
-
-val network_with_protocol :
-     ?do_activation:bool
-  -> ?node_custom_network:[`Json of Ezjsonm.value]
-  -> ?external_peer_ports:int list
-  -> ?base_port:int
-  -> ?size:int
-  -> ?protocol:Tezos_protocol.t
-  -> ?nodes_history_mode_edits:([> `Empty_protocol_list
-                                | System_error.t
-                                | Process_result.Error.t
-                                | Process_result.Error.t
-                                | `Too_many_protocols of Tezos_protocol.t list
-                                | `Too_many_timestamp_delays of
-                                  Tezos_protocol.t list
-                                | `Waiting_for of string * [`Time_out] ]
-                                as
-                                'errors)
-                               Tezos_node.History_modes.edit
-  -> < env_config: Environment_configuration.t
-     ; paths: Paths.t
-     ; console: Console.t
-     ; runner: Running_processes.State.t
-     ; .. >
-     Base_state.t
-  -> node_exec:Tezos_executable.t
-  -> client_exec:Tezos_executable.t
-  -> (Tezos_node.t list * Tezos_protocol.t, 'errors) Asynchronous_result.t
-(** [network_with_protocol] is a wrapper simply starting-up a
-    {!Topology.mesh}. See {!Network.start_up} for details on some arguments. *)
-
-(** Run queries on running networks. *)
-module Queries : sig
-  val all_levels :
-       ?chain:string
-    -> < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> nodes:Tezos_node.t list
-    -> ( (string * [> `Failed | `Level of int | `Null | `Unknown of string])
-         list
-       , [> System_error.t] )
-       Asynchronous_result.t
-  (** Get the current chain level for all the nodes, returns {i
-      node-ID × level } values. *)
-
-  val wait_for_all_levels_to_be :
-       ?attempts_factor:float
-    -> ?chain:string
-    -> < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> attempts:int
-    -> seconds:float
-    -> Tezos_node.t list
-    -> [< `At_least of int | `Equal_to of int]
-    -> ( unit
-       , [> System_error.t | `Waiting_for of string * [`Time_out]] )
-       Asynchronous_result.t
-  (** Try-sleep-loop waiting for all given nodes to reach a given level. *)
-end
diff --git a/vendors/flextesa-lib/tezos_admin_client.ml b/vendors/flextesa-lib/tezos_admin_client.ml
deleted file mode 100644
index 4f02a90430706d803069d17415d4900e9f3f77fb..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_admin_client.ml
+++ /dev/null
@@ -1,56 +0,0 @@
-open Internal_pervasives
-
-type t = {id: string; port: int; exec: Tezos_executable.t}
-
-let base_dir t ~state = Paths.root state // sprintf "Admin-client-base-%s" t.id
-
-let of_client ~exec n =
-  let id = sprintf "A-%s" n.Tezos_client.id in
-  let port = n.Tezos_client.port in
-  {id; port; exec}
-
-let of_node ~exec n =
-  let id = sprintf "C-%s" n.Tezos_node.id in
-  let port = n.Tezos_node.rpc_port in
-  {id; port; exec}
-
-let make_command state t args =
-  let open Tezos_executable.Make_cli in
-  Tezos_executable.call state t.exec
-    ~path:(base_dir t ~state // "exec-admin")
-    (optf "port" "%d" t.port @ opt "base-dir" (base_dir ~state t) @ args)
-
-module Command_error = struct
-  let failf ?client ?args fmt =
-    let attach =
-      Option.value_map ~default:[] args ~f:(fun l ->
-          [("arguments", `String_list l)])
-      @ Option.value_map ~default:[] client ~f:(fun c ->
-            [("client-id", `String_value c.id)]) in
-    Process_result.Error.wrong_behavior ~attach fmt
-end
-
-open Command_error
-
-let successful_command admin state args =
-  Running_processes.run_cmdf state "sh -c %s"
-    ( make_command state admin args
-    |> Genspio.Compile.to_one_liner |> Caml.Filename.quote )
-  >>= fun res ->
-  Console.display_errors_of_command state res
-  >>= function
-  | true -> return res
-  | false ->
-      failf ~args "Admin-command failure: %s" (String.concat ~sep:" " args)
-
-let inject_protocol admin state ~path =
-  successful_command admin state ["inject"; "protocol"; path]
-  >>= fun res ->
-  String.concat ~sep:" " res#out
-  |> String.split ~on:' ' |> List.map ~f:String.strip
-  |> (function
-       | _ :: _ :: hash :: _ when Char.equal hash.[0] 'P' -> return hash
-       | _ ->
-           failf "inject protocol: cannot parse hash of protocol: %s"
-             (String.concat ~sep:", " (List.map ~f:(sprintf "%S") res#out)))
-  >>= fun hash -> return (res, hash)
diff --git a/vendors/flextesa-lib/tezos_admin_client.mli b/vendors/flextesa-lib/tezos_admin_client.mli
deleted file mode 100644
index dce9e8d7fd9e4a78cfcefa8fa1da964bb3813e1f..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_admin_client.mli
+++ /dev/null
@@ -1,41 +0,0 @@
-open Internal_pervasives
-(** Wrapper around the [tezos-admin-client] application. *)
-
-type t = private {id: string; port: int; exec: Tezos_executable.t}
-(** [t] is very similar to {!Tezos_client.t}. *)
-
-val of_client : exec:Tezos_executable.t -> Tezos_client.t -> t
-val of_node : exec:Tezos_executable.t -> Tezos_node.t -> t
-
-val make_command :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> string list
-  -> unit Genspio.EDSL.t
-(** Build a [Genspio.EDSL.t] command. *)
-
-val successful_command :
-     t
-  -> < application_name: string
-     ; console: Console.t
-     ; env_config: Environment_configuration.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> string list
-  -> ( Process_result.t
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
-
-val inject_protocol :
-     t
-  -> < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; env_config: Environment_configuration.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> path:string
-  -> ( Process_result.t * string
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
diff --git a/vendors/flextesa-lib/tezos_client.ml b/vendors/flextesa-lib/tezos_client.ml
deleted file mode 100644
index c13eeff5c4d50a5d1dc9aea2f26d1f5a6f5177ff..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_client.ml
+++ /dev/null
@@ -1,401 +0,0 @@
-open Internal_pervasives
-
-type t = {id: string; port: int; exec: Tezos_executable.t}
-type client = t
-
-let no_node_client ~exec = {id= "C-null"; port= 0; exec}
-
-let of_node ~exec n =
-  let id = sprintf "C-%s" n.Tezos_node.id in
-  let port = n.Tezos_node.rpc_port in
-  {id; port; exec}
-
-let base_dir t ~state = Paths.root state // sprintf "Client-base-%s" t.id
-
-open Tezos_executable.Make_cli
-
-let client_call ?(wait = "none") state t args =
-  "--wait" :: wait :: optf "port" "%d" t.port
-  @ opt "base-dir" (base_dir ~state t)
-  @ args
-
-let client_command ?wait state t args =
-  Tezos_executable.call state t.exec
-    ~path:(base_dir t ~state // "exec-client")
-    (client_call ?wait state t args)
-
-module Command_error = struct
-  let failf ?result ?client ?args fmt =
-    let attach =
-      Option.value_map ~default:[] args ~f:(fun l ->
-          [("arguments", `String_list l)] )
-      @ Option.value_map ~default:[] client ~f:(fun c ->
-            [("client-id", `String_value c.id)] )
-      @ Option.value_map ~default:[] result ~f:(fun res ->
-            [("stdout", `Verbatim res#out); ("stderr", `Verbatim res#err)] )
-    in
-    Process_result.Error.wrong_behavior ~attach fmt
-end
-
-open Command_error
-open Console
-
-let run_client_cmd ?id_prefix ?wait state client args =
-  Running_processes.run_cmdf ?id_prefix state "sh -c %s"
-    ( client_command ?wait state client args
-    |> Genspio.Compile.to_one_liner |> Caml.Filename.quote )
-
-let client_cmd ?id_prefix ?(verbose = true) ?wait state ~client args =
-  Running_processes.run_cmdf ?id_prefix state "sh -c %s"
-    ( client_command ?wait state client args
-    |> Genspio.Compile.to_one_liner |> Caml.Filename.quote )
-  >>= fun res ->
-  let unix_success = Poly.equal res#status (Lwt_unix.WEXITED 0) in
-  ( if verbose then
-    Console.display_errors_of_command state res >>= fun _ -> return ()
-  else return () )
-  >>= fun () -> return (unix_success, res)
-
-let successful_client_cmd ?id_prefix ?(verbose = true) ?wait state ~client args
-    =
-  client_cmd ?id_prefix ~verbose state ?wait ~client args
-  >>= fun (success, result) ->
-  match success with
-  | true -> return result
-  | false ->
-      failf ~result ~client ~args "Client-command failure: %s"
-        (String.concat ~sep:" " args)
-
-let wait_for_node_bootstrap state client =
-  let try_once () =
-    run_client_cmd
-      ~id_prefix:(client.id ^ "-bootstrapped")
-      state client ["bootstrapped"]
-    >>= fun res -> return Poly.(res#status = Unix.WEXITED 0) in
-  let attempts = 20 in
-  let rec loop nth =
-    if nth >= attempts then failf "Bootstrapping failed %d times." nth
-    else
-      try_once ()
-      >>= function
-      | true -> return ()
-      | false ->
-          System.sleep Float.(0.3 + (of_int nth * 0.6))
-          >>= fun () -> loop (nth + 1) in
-  loop 1
-
-let import_secret_key state client ~name ~key =
-  successful_client_cmd state ~client
-    ["import"; "secret"; "key"; name; key; "--force"]
-  >>= fun _ -> return ()
-
-let register_as_delegate state client ~key_name =
-  successful_client_cmd state ~client
-    ["register"; "key"; key_name; "as"; "delegate"]
-  >>= fun _ -> return ()
-
-let rpc state ~client meth ~path =
-  let args =
-    match meth with
-    | `Get -> ["rpc"; "get"; path]
-    | `Post s -> ["rpc"; "post"; path; "with"; s] in
-  successful_client_cmd state ~client args
-  >>= fun res ->
-  let output = String.concat ~sep:"\n" res#out in
-  try
-    let json = Jqo.of_string output in
-    return json
-  with e -> (
-    try
-      Ezjsonm.from_string (sprintf "[ %s ]" output)
-      |> function `A [one] -> return one | _ -> raise e
-    with e ->
-      say state
-        EF.(
-          list
-            [ desc (shout "Output:") (markdown_verbatim output)
-            ; desc (shout "Error:")
-                (markdown_verbatim (String.concat ~sep:"\n" res#err)) ])
-      >>= fun () ->
-      failf ~args "RPC failure cannot parse json: %s" Exn.(to_string e) )
-
-let activate_protocol state client protocol =
-  let timestamp =
-    match protocol.Tezos_protocol.timestamp_delay with
-    | None -> []
-    | Some delay -> (
-        let now = Ptime_clock.now () in
-        match Ptime.add_span now (Ptime.Span.of_int_s delay) with
-        | None ->
-            invalid_arg "activate_protocol_script: protocol.timestamp_delay"
-        | Some x -> ["--timestamp"; Ptime.to_rfc3339 x] ) in
-  Console.say state
-    EF.(wf "Activating protocol %s" protocol.Tezos_protocol.hash)
-  >>= fun () ->
-  import_secret_key state client
-    ~name:(Tezos_protocol.dictator_name protocol)
-    ~key:(Tezos_protocol.dictator_secret_key protocol)
-  >>= fun () ->
-  successful_client_cmd state ~client
-    ( opt "block" "genesis"
-    @ [ "activate"; "protocol"; protocol.Tezos_protocol.hash; "with"; "fitness"
-      ; sprintf "%d" protocol.Tezos_protocol.expected_pow; "and"; "key"
-      ; Tezos_protocol.dictator_name protocol; "and"; "parameters"
-      ; Tezos_protocol.protocol_parameters_path state protocol ]
-    @ timestamp )
-  >>= fun _ ->
-  rpc state ~client `Get ~path:"/chains/main/blocks/head/metadata"
-  >>= fun metadata_json ->
-  ( match Jqo.field metadata_json ~k:"next_protocol" with
-  | `String hash when String.equal hash protocol.Tezos_protocol.hash ->
-      return ()
-  | exception e ->
-      System_error.fail_fatalf "Error getting protocol metadata: %a" Exn.pp e
-  | other_value ->
-      System_error.fail_fatalf "Error activating protocol: %s Vs %s"
-        (Ezjsonm.value_to_string other_value)
-        protocol.Tezos_protocol.hash )
-  >>= fun () -> return ()
-
-let find_applied_in_mempool state ~client ~f =
-  successful_client_cmd state ~client
-    ["rpc"; "get"; "/chains/main/mempool/pending_operations"]
-  >>= fun res ->
-  try
-    let json = Jqo.of_string (String.concat ~sep:"\n" res#out) in
-    let found = Jqo.field ~k:"applied" json |> Jqo.list_find ~f in
-    say state
-      EF.(
-        desc
-          (af "piece of mempool found (client %s):" client.id)
-          (markdown_verbatim (Ezjsonm.to_string json)))
-    >>= fun () -> return (Some found)
-  with e ->
-    say state
-      EF.(desc (shout "not found in mempool") (af "%s" (Exn.to_string e)))
-    >>= fun () -> return None
-
-let mempool_has_operation state ~client ~kind =
-  find_applied_in_mempool state ~client ~f:(fun o ->
-      Jqo.field o ~k:"contents"
-      |> Jqo.list_exists
-           ~f:Poly.(fun op -> Jqo.field op ~k:"kind" = `String kind) )
-  >>= fun found_or_not -> return Poly.(found_or_not <> None)
-
-let block_has_operation state ~client ~level ~kind =
-  successful_client_cmd state ~client
-    ["rpc"; "get"; sprintf "/chains/main/blocks/%d/operations" level]
-  >>= fun res ->
-  try
-    let json = Jqo.of_string (String.concat ~sep:"\n" res#out) in
-    let found =
-      Jqo.list_exists json ~f:(fun olist ->
-          Jqo.list_exists olist ~f:(fun o ->
-              Jqo.field o ~k:"contents"
-              |> Jqo.list_exists
-                   ~f:Poly.(fun op -> Jqo.field op ~k:"kind" = `String kind) ) )
-    in
-    say state
-      EF.(
-        desc
-          (af "looking for %S in block %d: %sfound" kind level
-             (if found then "" else "not ") )
-          (af "%s" (Ezjsonm.to_string json)))
-    >>= fun () -> return found
-  with e ->
-    say state
-      EF.(
-        desc
-          (ksprintf shout "Operation %S not found in block" kind)
-          (af "%s" (Exn.to_string e)))
-    >>= fun () -> return false
-
-let get_block_header state ~client block =
-  let path =
-    sprintf "/chains/main/blocks/%s/header"
-      (match block with `Head -> "head" | `Level i -> Int.to_string i) in
-  rpc state ~client `Get ~path
-
-let list_known_addresses state ~client =
-  successful_client_cmd state ~client ["list"; "known"; "addresses"]
-  >>= fun res ->
-  let re =
-    Re.(
-      compile
-        (seq
-           [ group (rep1 (alt [alnum; char '_'])); str ": "; group (rep1 alnum)
-           ; alt [space; eol; eos] ] )) in
-  return
-    (List.filter_map res#out
-       ~f:
-         Re.(
-           fun line ->
-             match exec_opt re line with
-             | None -> None
-             | Some matches -> Some (Group.get matches 1, Group.get matches 2)) )
-
-module Ledger = struct
-  type hwm = {main: int; test: int; chain: Tezos_crypto.Chain_id.t option}
-
-  let set_hwm state ~client ~uri ~level =
-    successful_client_cmd state ~client
-      [ "set"; "ledger"; "high"; "watermark"; "for"; uri; "to"
-      ; Int.to_string level ]
-    >>= fun _ -> return ()
-
-  let get_hwm state ~client ~uri =
-    successful_client_cmd state ~client
-      [ "get"; "ledger"; "high"; "watermark"; "for"; uri
-      ; "--no-legacy-instructions" ]
-    (* TODO: Use --for-script when available *)
-    >>= fun res ->
-    (* e.g. The high water mark values for married-bison-ill-burmese/P-256 are
-            0 for the main-chain (NetXH12Aer3be93) and
-            0 for the test-chain. *)
-    let re =
-      Re.(
-        let num = rep1 digit in
-        compile
-          (seq
-             [ group num; str " for the main-chain ("; group (rep1 alnum)
-             ; str ") and "; group num; str " for the test-chain." ] )) in
-    let matches = Re.exec re (String.concat ~sep:" " res#out) in
-    try
-      return
-        { main= Int.of_string (Re.Group.get matches 1)
-        ; chain=
-            (let v = Re.Group.get matches 2 in
-             if String.equal v "'Unspecified'" then None
-             else Some (Tezos_crypto.Chain_id.of_b58check_exn v) )
-        ; test= Int.of_string (Re.Group.get matches 3) }
-    with e ->
-      failf
-        "Couldn't understand result of 'get high watermark for %S': error %S: \
-         from %S"
-        uri (Exn.to_string e)
-        (String.concat ~sep:"\n" res#out)
-
-  let show_ledger state ~client ~uri =
-    successful_client_cmd state ~client ["show"; "ledger"; uri]
-    (* TODO: Use --for-script when available *)
-    >>= fun res ->
-    list_known_addresses state ~client
-    >>= fun known_addresses ->
-    let pk = Re.(rep1 alnum) in
-    let addr_re = Re.(compile (seq [str "* Public Key Hash: "; group pk])) in
-    let pubkey_re = Re.(compile (seq [str "* Public Key: "; group pk])) in
-    let out = String.concat ~sep:" " res#out in
-    try
-      let pubkey = Re.(Group.get (exec pubkey_re out) 1) in
-      let pubkey_hash = Re.(Group.get (exec addr_re out) 1) in
-      let name =
-        match
-          List.find known_addresses ~f:(fun (_, pkh) ->
-              String.equal pkh pubkey_hash )
-        with
-        | None -> ""
-        | Some (alias, _) -> alias in
-      return
-        (Tezos_protocol.Account.key_pair name ~pubkey ~pubkey_hash
-           ~private_key:uri )
-    with e ->
-      failf "Couldn't understand result of 'show ledger %S': error %S: from %S"
-        uri (Exn.to_string e)
-        (String.concat ~sep:"\n" res#out)
-
-  let deauthorize_baking state ~client ~uri =
-    successful_client_cmd state ~client
-      ["deauthorize"; "ledger"; "baking"; "for"; uri]
-    >>= fun _ -> return ()
-
-  let get_authorized_key state ~client ~uri =
-    successful_client_cmd state ~client
-      ["get"; "ledger"; "authorized"; "path"; "for"; uri]
-    >>= fun res ->
-    let re_uri =
-      Re.(compile (seq [str "Authorized baking URI: "; group (rep1 any); eol]))
-    in
-    let re_none = Re.(compile (str "No baking key authorized")) in
-    let out = String.concat ~sep:" " res#out in
-    return
-      Re.(
-        match exec_opt re_none out with
-        | Some _ -> None
-        | None -> Some (Group.get (exec re_uri out) 1))
-end
-
-module Keyed = struct
-  type t = {client: client; key_name: string; secret_key: string}
-
-  let make client ~key_name ~secret_key = {client; key_name; secret_key}
-
-  let initialize state {client; key_name; secret_key} =
-    successful_client_cmd state ~client
-      ["import"; "secret"; "key"; key_name; secret_key; "--force"]
-
-  let bake ?chain state baker msg =
-    let chain_arg =
-      Option.value_map chain ~default:[] ~f:(fun c -> ["--chain"; c]) in
-    successful_client_cmd state ~client:baker.client
-      ( chain_arg
-      @ ["bake"; "for"; baker.key_name; "--force"; "--minimal-timestamp"] )
-    >>= fun res ->
-    Log_recorder.Operations.bake state ~client:baker.client.id ~output:res#out
-      msg ;
-    say state
-      EF.(
-        desc
-          (af "Successful bake (%s: %s):" baker.client.id msg)
-          (ocaml_string_list res#out))
-
-  let endorse state baker msg =
-    successful_client_cmd state ~client:baker.client
-      ["endorse"; "for"; baker.key_name]
-    >>= fun res ->
-    Log_recorder.Operations.endorse state ~client:baker.client.id
-      ~output:res#out msg ;
-    say state
-      EF.(
-        desc
-          (af "Successful endorse (%s: %s):" baker.client.id msg)
-          (ocaml_string_list res#out))
-
-  let generate_nonce state {client; key_name; _} data =
-    successful_client_cmd state ~client
-      ["generate"; "nonce"; "hash"; "for"; key_name; "from"; data]
-    >>= fun res -> return (List.hd_exn res#out)
-
-  let forge_and_inject state {client; key_name; _} ~json =
-    rpc state ~client ~path:"/chains/main/blocks/head/helpers/forge/operations"
-      (`Post (Ezjsonm.value_to_string json))
-    >>= fun res ->
-    let operation_bytes = match res with `String s -> s | _ -> assert false in
-    let bytes_to_sign = "0x03" ^ operation_bytes in
-    successful_client_cmd state ~client
-      ["sign"; "bytes"; bytes_to_sign; "for"; key_name]
-    >>= fun sign_res ->
-    let to_decode =
-      List.hd_exn sign_res#out
-      |> String.chop_prefix_exn ~prefix:"Signature:"
-      |> String.strip in
-    say state EF.(desc (shout "TO DECODE:") (af "%S" to_decode))
-    >>= fun () ->
-    let decoded =
-      Option.value_exn ~message:"base58 dec"
-        (Tezos_crypto.Base58.safe_decode to_decode)
-      |> Hex.of_string ?ignore:None |> Hex.show in
-    say state EF.(desc (shout "DECODED:") (af "%S" decoded))
-    >>= fun () ->
-    let actual_signature = String.chop_prefix_exn ~prefix:"09f5cd8612" decoded in
-    say state
-      EF.(
-        desc_list (af "Injecting Operation")
-          [ ef_json "Injecting" (json :> Ezjsonm.value)
-          ; desc (haf "op:")
-              (af "%d: %S" (String.length operation_bytes) operation_bytes)
-          ; desc (haf "sign:")
-              (af "%d: %S" (String.length actual_signature) actual_signature) ])
-    >>= fun () ->
-    rpc state ~client ~path:"/injection/operation?chain=main"
-      (`Post (sprintf "\"%s%s\"" operation_bytes actual_signature))
-end
diff --git a/vendors/flextesa-lib/tezos_client.mli b/vendors/flextesa-lib/tezos_client.mli
deleted file mode 100644
index cc9e554605c546ac33503a099ff7c7b7b032591e..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_client.mli
+++ /dev/null
@@ -1,335 +0,0 @@
-open Internal_pervasives
-(** Wrapper around the main ["tezos-client"] application. *)
-
-type t = {id: string; port: int; exec: Tezos_executable.t}
-type client = t
-
-val of_node : exec:Tezos_executable.t -> Tezos_node.t -> t
-(** Create a client which is meant to communicate with a given node. *)
-
-val no_node_client : exec:Tezos_executable.t -> t
-(** Create a client not connected to a node (e.g. for ledger interaction). *)
-
-val base_dir : t -> state:< paths: Paths.t ; .. > -> string
-(** Get the path to the ["--base-dir"] option of the client. *)
-
-(** {3 Build Scripts } *)
-
-val client_call :
-     ?wait:string
-  -> < paths: Paths.t ; .. >
-  -> client
-  -> string list
-  -> string list
-(** Build the arguments for a given default tezos-client (not
-    including the executable). *)
-
-val client_command :
-     ?wait:string
-  -> < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> client
-  -> string list
-  -> unit Genspio.Language.t
-(** Build a tezos-client command, the default [?wait] is ["none"]. *)
-
-(** {3 Run Specific Client Commands } *)
-
-val wait_for_node_bootstrap :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-  -> client
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-(** Wait for the node to be bootstrapped. *)
-
-val import_secret_key :
-     < paths: Paths.t
-     ; console: Console.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-     Base_state.t
-  -> t
-  -> name:string
-  -> key:string
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-
-val register_as_delegate :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-  -> client
-  -> key_name:string
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-
-val activate_protocol :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-  -> client
-  -> Tezos_protocol.t
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-
-val client_cmd :
-     ?id_prefix:string
-  -> ?verbose:bool
-  -> ?wait:string
-  -> < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; env_config: Environment_configuration.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> client:client
-  -> string list
-  -> (bool * Process_result.t, [> System_error.t]) Asynchronous_result.t
-
-val successful_client_cmd :
-     ?id_prefix:string
-  -> ?verbose:bool
-  -> ?wait:string
-  -> < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-     Base_state.t
-  -> client:t
-  -> string list
-  -> ( < err: string list ; out: string list ; status: Unix.process_status >
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
-
-val rpc :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-     Base_state.t
-  -> client:t
-  -> [< `Get | `Post of string]
-  -> path:string
-  -> ( Ezjsonm.value
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
-
-val find_applied_in_mempool :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; env_config: Environment_configuration.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> client:client
-  -> f:(Ezjsonm.value -> bool)
-  -> ( Ezjsonm.value option
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
-(** Use RPCs to find an operation matching [~f] in the node's mempool. *)
-
-val mempool_has_operation :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; env_config: Environment_configuration.t
-     ; .. >
-  -> client:t
-  -> kind:string
-  -> (bool, [> Process_result.Error.t | System_error.t]) Asynchronous_result.t
-(** Use RPCs to find an operation of kind [~kind] in the node's mempool. *)
-
-val block_has_operation :
-     < application_name: string
-     ; console: Console.t
-     ; env_config: Environment_configuration.t
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> client:t
-  -> level:int
-  -> kind:string
-  -> (bool, [> Process_result.Error.t | System_error.t]) Asynchronous_result.t
-(** Use RPCs to find an operation of kind [~kind] in the node's chain
-    at a given level. *)
-
-val get_block_header :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; env_config: Environment_configuration.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> client:t
-  -> [`Head | `Level of int]
-  -> ( Ezjsonm.value
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
-(** Call the RPC ["/chains/main/blocks/<block>/header"]. *)
-
-val list_known_addresses :
-     < application_name: string
-     ; console: Console.t
-     ; paths: Paths.t
-     ; env_config: Environment_configuration.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> client:t
-  -> ( (string * string) list
-     , [> Process_result.Error.t | System_error.t] )
-     Asynchronous_result.t
-
-module Ledger : sig
-  type hwm = {main: int; test: int; chain: Tezos_crypto.Chain_id.t option}
-
-  val get_hwm :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:t
-    -> uri:string
-    -> (hwm, [> Process_result.Error.t | System_error.t]) Asynchronous_result.t
-
-  val set_hwm :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:t
-    -> uri:string
-    -> level:int
-    -> ( unit
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val show_ledger :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:t
-    -> uri:string
-    -> ( Tezos_protocol.Account.t
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val deauthorize_baking :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:t
-    -> uri:string
-    -> ( unit
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val get_authorized_key :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> client:t
-    -> uri:string
-    -> ( string option
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-end
-
-module Keyed : sig
-  type t = {client: client; key_name: string; secret_key: string}
-
-  val make : client -> key_name:string -> secret_key:string -> t
-
-  val initialize :
-       < application_name: string
-       ; console: Console.t
-       ; paths: Paths.t
-       ; env_config: Environment_configuration.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> t
-    -> ( < err: string list ; out: string list ; status: Unix.process_status >
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-  (** Get the keyed-client ready to use (i.e. import the secret key). *)
-
-  val bake :
-       ?chain:string
-    -> < application_name: string
-       ; console: Console.t
-       ; operations_log: Log_recorder.Operations.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> t
-    -> string
-    -> ( unit
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val endorse :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; operations_log: Log_recorder.Operations.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> t
-    -> string
-    -> ( unit
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val generate_nonce :
-       < application_name: string
-       ; console: Console.t
-       ; operations_log: Log_recorder.Operations.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> t
-    -> string
-    -> ( string
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-
-  val forge_and_inject :
-       < application_name: string
-       ; env_config: Environment_configuration.t
-       ; console: Console.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> t
-    -> json:Ezjsonm.value
-    -> ( Ezjsonm.value
-       , [> Process_result.Error.t | System_error.t] )
-       Asynchronous_result.t
-end
diff --git a/vendors/flextesa-lib/tezos_daemon.ml b/vendors/flextesa-lib/tezos_daemon.ml
deleted file mode 100644
index 40c15030806f710e6147ac7db50a822484ceb716..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_daemon.ml
+++ /dev/null
@@ -1,69 +0,0 @@
-open Internal_pervasives
-
-type baker_args = {key : string; lb_vote : string option}
-
-type args =
-  | Baker : baker_args -> args
-  | Endorser : string -> args
-  | Accuser : args
-
-type t =
-  { node: Tezos_node.t
-  ; client: Tezos_client.t
-  ; exec: Tezos_executable.t
-  ; args: args
-  ; name_tag: string option }
-
-let of_node ?name_tag node args ~exec ~client =
-  {node; exec; client; args; name_tag}
-
-let baker_of_node ?name_tag nod ~key ~lb_vote =
-  of_node nod ?name_tag (Baker {key; lb_vote})
-let endorser_of_node ?name_tag nod ~key = of_node nod ?name_tag (Endorser key)
-let accuser_of_node ?name_tag nod = of_node ?name_tag nod Accuser
-
-let arg_to_string = function
-  | Baker {key; lb_vote = _} -> sprintf "baker-%s" key
-  | Endorser k -> sprintf "endorser-%s" k
-  | Accuser -> "accuser"
-
-let to_script state (t : t) =
-  let base_dir = Tezos_client.base_dir ~state t.client in
-  let call t args =
-    Tezos_executable.call state t.exec
-      ~path:
-        ( base_dir
-        // sprintf "exec-%s-%d%s" (arg_to_string t.args)
-             t.node.Tezos_node.rpc_port
-             (Option.value_map t.name_tag ~default:"" ~f:(sprintf "-%s")) )
-      args in
-  match t.args with
-  | Baker {key; lb_vote} ->
-      let node_path = Tezos_node.data_dir state t.node in
-      let lb_vote =
-        match lb_vote with
-        | None -> []
-        | Some vote -> ["--liquidity-baking-toggle-vote"; vote]
-      in
-      call t @@
-        [ "--endpoint"
-        ; sprintf "http://localhost:%d" t.node.Tezos_node.rpc_port
-        ; "--base-dir"; base_dir; "run"; "with"; "local"; "node"; node_path ]
-        @ lb_vote
-        @ [ key ]
-  | Endorser key ->
-      call t
-        [ "--endpoint"
-        ; sprintf "http://localhost:%d" t.node.Tezos_node.rpc_port
-        ; "--base-dir"; base_dir; "run"; key ]
-  | Accuser ->
-      call t
-        [ "--endpoint"
-        ; sprintf "http://localhost:%d" t.node.Tezos_node.rpc_port
-        ; "--base-dir"; base_dir; "run"; "--preserved-levels"; "10" ]
-
-let process state (t : t) =
-  Running_processes.Process.genspio
-    (sprintf "%s-for-%s%s" (arg_to_string t.args) t.node.Tezos_node.id
-       (Option.value_map t.name_tag ~default:"" ~f:(sprintf "-%s")))
-    (to_script state t)
diff --git a/vendors/flextesa-lib/tezos_daemon.mli b/vendors/flextesa-lib/tezos_daemon.mli
deleted file mode 100644
index 439b7cb88c35476b4df62b818de26963490bf024..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_daemon.mli
+++ /dev/null
@@ -1,57 +0,0 @@
-type baker_args = {key : string; lb_vote : string option}
-
-type args = private
-  | Baker : baker_args -> args
-  | Endorser : string -> args
-  | Accuser : args
-
-type t = private
-  { node: Tezos_node.t
-  ; client: Tezos_client.t
-  ; exec: Tezos_executable.t
-  ; args: args
-  ; name_tag: string option }
-
-val of_node :
-     ?name_tag:string
-  -> Tezos_node.t
-  -> args
-  -> exec:Tezos_executable.t
-  -> client:Tezos_client.t
-  -> t
-
-val baker_of_node :
-     ?name_tag:string
-  -> Tezos_node.t
-  -> key:string
-  -> lb_vote:string option
-  -> exec:Tezos_executable.t
-  -> client:Tezos_client.t
-  -> t
-
-val endorser_of_node :
-     ?name_tag:string
-  -> Tezos_node.t
-  -> key:string
-  -> exec:Tezos_executable.t
-  -> client:Tezos_client.t
-  -> t
-
-val accuser_of_node :
-     ?name_tag:string
-  -> Tezos_node.t
-  -> exec:Tezos_executable.t
-  -> client:Tezos_client.t
-  -> t
-
-val arg_to_string : args -> string
-
-val to_script :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> unit Genspio.Language.t
-
-val process :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> Running_processes.Process.t
diff --git a/vendors/flextesa-lib/tezos_executable.ml b/vendors/flextesa-lib/tezos_executable.ml
deleted file mode 100644
index ee9d6d719d198a5835c2db067c8bbb831f8eca6a..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_executable.ml
+++ /dev/null
@@ -1,74 +0,0 @@
-open Internal_pervasives
-
-module Make_cli = struct
-  let flag name = [sprintf "--%s" name]
-  let opt name s = [sprintf "--%s" name; s]
-  let optf name fmt = ksprintf (opt name) fmt
-end
-
-module Unix_files_sink = struct
-  type t = {matches: string list option; level_at_least: string}
-
-  let all_at_least level_at_least = {matches= None; level_at_least}
-  let all_notices = all_at_least "notice"
-  let all_info = all_at_least "info"
-end
-
-type kind = [`Node | `Baker | `Endorser | `Accuser | `Client | `Admin]
-
-type t =
-  { kind: kind
-  ; binary: string option
-  ; unix_files_sink: Unix_files_sink.t option
-  ; environment: (string * string) list }
-
-let make ?binary ?unix_files_sink ?(environment = []) (kind : [< kind]) =
-  {kind; binary; unix_files_sink; environment}
-
-let kind_string (kind : [< kind]) =
-  match kind with
-  | `Accuser -> "accuser-alpha"
-  | `Baker -> "baker-alpha"
-  | `Endorser -> "endorser-alpha"
-  | `Node -> "node"
-  | `Client -> "client"
-  | `Admin -> "admin-client"
-
-let default_binary t = sprintf "tezos-%s" (kind_string t.kind)
-let get t = Option.value t.binary ~default:(default_binary t)
-
-let call state t ~path args =
-  let open Genspio.EDSL in
-  let unix_files_sink =
-    match t.unix_files_sink with
-    | Some s -> Some s
-    | None ->
-        Environment_configuration.default_events_level state
-        |> Option.map ~f:Unix_files_sink.all_at_least in
-  seq
-    ( Option.value_map unix_files_sink ~default:[] ~f:(function
-        | {matches= None; level_at_least} ->
-            [ setenv
-                ~var:(str "TEZOS_EVENTS_CONFIG")
-                (ksprintf str "unix-files://%s?level-at-least=%s"
-                   (path // "events") level_at_least) ]
-        | _other -> assert false)
-    @ [ exec ["mkdir"; "-p"; path]
-      ; write_stdout
-          ~path:(path // "last-cmd" |> str)
-          (printf (str "ARGS: %s\\n") [str (String.concat ~sep:" " args)])
-      ; exec (get t :: args) ] )
-
-let cli_term ?(extra_doc = "") state kind prefix =
-  let open Cmdliner in
-  let open Term in
-  let docs = Manpage_builder.section state ~rank:2 ~name:"EXECUTABLE PATHS" in
-  pure (fun binary -> {kind; binary; unix_files_sink= None; environment= []})
-  $ Arg.(
-      value
-      & opt (some string) None
-      & info ~docs
-          [sprintf "%s-%s-binary" prefix (kind_string kind)]
-          ~doc:
-            (sprintf "Binary for the `tezos-%s` to use%s." (kind_string kind)
-               extra_doc))
diff --git a/vendors/flextesa-lib/tezos_executable.mli b/vendors/flextesa-lib/tezos_executable.mli
deleted file mode 100644
index 9e9be7a669abce5fac25a0c6d9253e36abcb9cc8..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_executable.mli
+++ /dev/null
@@ -1,67 +0,0 @@
-(** This module wraps the type ['kind t] around the notion of
-    tezos-executable: a path to a binary with tezos-specific properties. *)
-
-(** Helper functions to construct exec-style command lines for
-    ["tezos-*"] applications. *)
-module Make_cli : sig
-  val flag : string -> string list
-  val opt : string -> string -> string list
-  val optf : string -> ('a, unit, string, string list) format4 -> 'a
-end
-
-(** Manipulate the ["TEZOS_EVENTS_CONFIG"] environment variable. *)
-module Unix_files_sink : sig
-  type t = private {matches: string list option; level_at_least: string}
-
-  val all_notices : t
-  val all_info : t
-end
-
-type kind = [`Node | `Baker | `Endorser | `Accuser | `Client | `Admin]
-(** The type [kind] is used to distinguish ['a t] executables. *)
-
-type t = private
-  { kind: kind
-  ; binary: string option
-  ; unix_files_sink: Unix_files_sink.t option
-  ; environment: (string * string) list }
-(** The wrapper of the tezos-executable. *)
-
-val make :
-     ?binary:string
-  -> ?unix_files_sink:Unix_files_sink.t
-  -> ?environment:(string * string) list
-  -> kind
-  -> t
-(** Create a ["tezos-node"] executable. *)
-
-val kind_string : kind -> string
-(** Convert a [kind] to a [string]. *)
-
-val default_binary : t -> string
-(** Get the path/name of the default binary for a given kind, e.g.,
-    ["tezos-admin-client"]. *)
-
-val get : t -> string
-(** The path to the executable. *)
-
-val call :
-     < env_config: Environment_configuration.t ; .. >
-  -> t
-  -> path:string
-  -> string list
-  -> unit Genspio.EDSL.t
-(** Build a [Genspio.EDSL.t] script to run a tezos command, the
-    [~path] argument is used as a toplevel path for the unix-files
-    event-sink (event-logging-framework) and for other local logging
-    files. *)
-
-val cli_term :
-     ?extra_doc:string
-  -> < manpager: Internal_pervasives.Manpage_builder.State.t ; .. >
-  -> kind
-  -> string
-  -> t Cmdliner.Term.t
-(** Build a [Cmdliner] term which creates tezos-executables, the
-    second argument is a prefix of option names (e.g. ["tezos"] for the
-    option ["--tezos-accuser-alpha-binary"]). *)
diff --git a/vendors/flextesa-lib/tezos_node.ml b/vendors/flextesa-lib/tezos_node.ml
deleted file mode 100644
index dc1f7d309f2494225751cb52688e4263d19d4f46..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_node.ml
+++ /dev/null
@@ -1,299 +0,0 @@
-open Internal_pervasives
-
-type custom_network = [`Json of Ezjsonm.value]
-
-type t =
-  { id: string
-  ; expected_connections: int
-  ; rpc_port: int
-  ; p2p_port: int
-  ; (* Ports: *)
-    peers: int list
-  ; exec: Tezos_executable.t
-  ; protocol: Tezos_protocol.t
-  ; history_mode: [`Archive | `Full of int | `Rolling of int] option
-  ; single_process: bool
-  ; cors_origin: string option
-  ; custom_network: custom_network option }
-
-let compare a b = Base.String.compare a.id b.id
-let equal a b = Base.String.equal a.id b.id
-
-let ef t =
-  EF.(
-    desc_list (af "Node:%S" t.id)
-      [ desc (af "rpc") (af ":%d" t.rpc_port)
-      ; desc (af "p2p") (af ":%d" t.p2p_port)
-      ; desc_list (af "peers") (List.map t.peers ~f:(af ":%d")) ])
-
-let pp fmt t = Easy_format.Pretty.to_formatter fmt (ef t)
-let id t = t.id
-
-let make ?cors_origin ~exec ?(protocol = Tezos_protocol.default ())
-    ?custom_network ?(single_process = true) ?history_mode id
-    ~expected_connections ~rpc_port ~p2p_port peers =
-  { id
-  ; expected_connections
-  ; rpc_port
-  ; p2p_port
-  ; peers
-  ; exec
-  ; protocol
-  ; history_mode
-  ; single_process
-  ; cors_origin
-  ; custom_network }
-
-let make_path p ~config t = Paths.root config // sprintf "node-%s" t.id // p
-
-(* Data-dir should not exist OR be fully functional. *)
-let data_dir config t = make_path "data-dir" ~config t
-let config_file config t = data_dir config t // "config.json"
-let identity_file config t = data_dir config t // "identity.json"
-let log_output config t = make_path "node-output.log" ~config t
-let exec_path config t = make_path ~config "exec" t
-
-module Config_file = struct
-  (*
-     This module purposely avoids using the node's modules because we
-     want the sandbox to be able to configure ≥ 1 versions of the
-     node.
-
-     Choosing the default hash:
-
-      $ ./flextesa vani SBox --att 10_000_000
-     Flextesa.vanity-chain-id:  Looking for "SBox"
-     Flextesa.vanity-chain-id:
-       Results:
-         * Seed: "flextesa5316422" → block: "BLdZYwNF8Rn6zrTWkuRRNyrj6bQWPkfBog2YKhWhn5z3ApmpzBf" → chain-id: "NetXKMbjQL2SBox"
-
-
-   *)
-
-  open Tezos_rpc_http_server
-
-  let network
-      ?(genesis_hash = "BLdZYwNF8Rn6zrTWkuRRNyrj6bQWPkfBog2YKhWhn5z3ApmpzBf") ()
-      =
-    let open Ezjsonm in
-    [ ( "genesis"
-      , dict
-          [ ("timestamp", string "2018-06-30T16:07:32Z")
-          ; ("block", string genesis_hash)
-          ; ( "protocol"
-            , string "Ps9mPmXaRzmzk35gbAYNCAw6UXdE2qoABTHbN2oEEc1qM7CwT9P" ) ]
-      ); ("chain_name", string "TEZOS_MAINNET")
-    ; ("old_chain_name", string "TEZOS_BETANET_2018-06-30T16:07:32Z")
-    ; ("incompatible_chain_name", string "INCOMPATIBLE")
-    ; ("sandboxed_chain_name", string "SANDBOXED_TEZOS_MAINNET") ]
-
-  let default_network = network ()
-
-  (* These tests try to do more than the default RPC ACL allows over the
-     network. Even though all processes are run on localhost, nodes are set up
-     to listen to RPC requests on address 0.0.0.0 (see below), which matches all
-     possible addresses. Hence the "localhost rule" of RPC ACLs does not apply
-     and the secure ACL is chosen by default. Thus a specific, more permissive
-     policy is needed. For more details see Node Configuration manual page or
-     https://gitlab.com/tezos/tezos/-/merge_requests/3164#note_616452409 *)
-  let acl : string list =
-    match RPC_server.Acl.secure with
-    | Allow_all _ ->
-        raise
-          (Failure
-             "Expected RPC secure ACL in the form of whitelist. Got a \
-              blacklist instead." )
-    | Deny_all {except} ->
-        List.map ~f:RPC_server.Acl.matcher_to_string except
-        @ [ "GET /chains/*/blocks/*/helpers/baking_rights"
-          ; "GET /chains/*/blocks/*/helpers/endorsing_rights"
-          ; "GET /chains/*/blocks/*/helpers/proposers"
-          ; "GET /chains/*/blocks/*/helpers/validators"
-          ; "GET /chains/*/blocks/*/helpers/levels_in_current_cycle"
-          ; "POST /chains/*/blocks/*/helpers/forge/operations"
-          ; "POST /chains/*/blocks/*/helpers/preapply/*"
-          ; "POST /chains/*/blocks/*/helpers/scripts/run_operation"
-          ; "POST /chains/*/blocks/*/helpers/scripts/simulate_operation"
-          ; "POST /chains/*/mempool/request_operations"; "POST /injection/block"
-          ; "POST /injection/protocol" ]
-
-  let of_node state t =
-    let open Ezjsonm in
-    let shell =
-      match t.history_mode with
-      | None -> []
-      | Some h ->
-          [ ( "shell"
-            , dict
-                [ ( "history_mode"
-                  , match h with
-                    | `Archive -> string "archive"
-                    | `Full off ->
-                        dict [("full", dict [("additional_cycles", int off)])]
-                    | `Rolling off ->
-                        dict [("rolling", dict [("additional_cycles", int off)])]
-                  ) ] ) ] in
-    let network =
-      Option.value_map t.custom_network
-        ~default:[("network", `O default_network)]
-        ~f:(function `Json j -> [("network", j)]) in
-    let rpc_listen_addr = sprintf "0.0.0.0:%d" t.rpc_port in
-    [ ("data-dir", data_dir state t |> string)
-    ; ( "rpc"
-      , dict
-          [ ("listen-addrs", strings [rpc_listen_addr])
-          ; ( "acl"
-            , list dict
-                [ [ ("address", string rpc_listen_addr)
-                  ; ("whitelist", strings acl) ] ] ) ] )
-    ; ( "p2p"
-      , dict
-          [ ( "expected-proof-of-work"
-            , int (Tezos_protocol.expected_pow t.protocol) )
-          ; ("listen-addr", ksprintf string "0.0.0.0:%d" t.p2p_port)
-          ; ( "limits"
-            , dict
-                [ ("maintenance-idle-time", int 3); ("swap-linger", int 2)
-                ; ("connection-timeout", int 2) ] ) ] )
-    ; ("log", dict [("output", string (log_output state t))]) ]
-    @ shell @ network
-    |> dict |> to_string ~minify:false
-end
-
-open Tezos_executable.Make_cli
-
-let node_command state t cmd options =
-  Tezos_executable.call state t.exec ~path:(exec_path state t)
-    ( cmd
-    @ opt "config-file" (config_file state t)
-    @ opt "data-dir" (data_dir state t)
-    @ options )
-
-let run_command state t =
-  let peers = List.concat_map t.peers ~f:(optf "peer" "127.0.0.1:%d") in
-  let cors_origin =
-    match t.cors_origin with
-    | Some _ as s -> s
-    | None -> Environment_configuration.default_cors_origin state in
-  node_command state t ["run"]
-    ( flag "private-mode" @ flag "no-bootstrap-peers" @ peers
-    @ optf "synchronisation-threshold" "0"
-    @ optf "connections" "%d" t.expected_connections
-    @ (if t.single_process then flag "singleprocess" else [])
-    @ Option.value_map cors_origin
-        ~f:(fun s ->
-          flag "cors-header=content-type" @ Fmt.kstr flag "cors-origin=%s" s )
-        ~default:[]
-    @ opt "sandbox" (Tezos_protocol.sandbox_path state t.protocol) )
-
-let start_script state t =
-  let open Genspio.EDSL in
-  let gen_id =
-    node_command state t
-      [ "identity"; "generate"
-      ; sprintf "%d" (Tezos_protocol.expected_pow t.protocol) ]
-      [] in
-  let tmp_config = tmp_file (config_file state t) in
-  check_sequence ~verbosity:`Output_all
-    [ ("reset-config", node_command state t ["config"; "reset"] [])
-    ; ( "write-config"
-      , seq
-          [ tmp_config#set (Config_file.of_node state t |> str)
-          ; call [str "mv"; tmp_config#path; str (config_file state t)] ] )
-    ; ( "ensure-identity"
-      , ensure "node-id"
-          ~condition:(file_exists (str (identity_file state t)))
-          ~how:[("gen-id", gen_id)] ); ("start", run_command state t) ]
-
-let process state t =
-  Running_processes.Process.genspio t.id (start_script state t)
-
-let protocol t = t.protocol
-
-let connections node_list =
-  let module Connection = struct
-    type node = t
-
-    type t =
-      [`Duplex of node * node | `From_to of node * node | `Missing of node * int]
-
-    let compare a b =
-      match (a, b) with
-      | `Duplex (a, b), `Duplex (c, d) when equal a d && equal b c -> 0
-      | `Duplex _, _ -> -1
-      | _, `Duplex _ -> 1
-      | _, _ -> Caml.compare a b
-  end in
-  let module Connection_set = Caml.Set.Make (Connection) in
-  let res = ref Connection_set.empty in
-  List.iter node_list ~f:(fun node ->
-      let peer_nodes =
-        List.map node.peers ~f:(fun p2p ->
-            match
-              List.find node_list ~f:(fun {p2p_port; _} -> p2p_port = p2p)
-            with
-            | None -> `Unknown p2p
-            | Some n -> `Peer n ) in
-      List.iter peer_nodes ~f:(fun peer_opt ->
-          let conn =
-            match peer_opt with
-            | `Unknown p2p -> `Missing (node, p2p)
-            | `Peer peer ->
-                if List.mem peer.peers node.p2p_port ~equal:Int.equal then
-                  `Duplex (node, peer)
-                else `From_to (node, peer) in
-          res := Connection_set.add conn !res ) ) ;
-  Connection_set.elements !res
-
-module History_modes = struct
-  type 'error edit = t list -> (t list, 'error) Asynchronous_result.t
-
-  let cmdliner_term state : _ edit Cmdliner.Term.t =
-    let open Cmdliner in
-    let open Term in
-    let history_mode_converter =
-      Arg.enum
-        [("archive", `Archive); ("full", `Full 5); ("rolling", `Rolling 5)]
-    in
-    let docs =
-      Manpage_builder.section state ~rank:2 ~name:"NODE HISTORY MODES"
-        ~man:
-          [`P "One can specify history modes for a given subset of the nodes."]
-    in
-    pure (fun edits node_list ->
-        try
-          return
-            (List.map node_list ~f:(fun node ->
-                 match
-                   List.filter edits ~f:(fun (prefix, _) ->
-                       String.is_prefix node.id ~prefix )
-                 with
-                 | [] -> node
-                 | [one] -> (
-                   match
-                     List.filter node_list ~f:(fun n ->
-                         String.is_prefix n.id ~prefix:(fst one) )
-                   with
-                   | [_] -> {node with history_mode= Some (snd one)}
-                   | a_bunch_maybe_zero ->
-                       Fmt.kstr failwith
-                         "Prefix %S does not match exactly one node: [%s]"
-                         (fst one)
-                         (String.concat ~sep:", "
-                            (List.map a_bunch_maybe_zero ~f:id) ) )
-                 | more ->
-                     Fmt.kstr failwith "Prefixes %s match the same node: %s"
-                       (String.concat ~sep:", " (List.map more ~f:fst))
-                       node.id ) )
-        with Failure s ->
-          System_error.fail_fatalf "Failed to compose history-modes: %s" s )
-    $ Arg.(
-        value
-          (opt_all
-             (pair ~sep:':' string history_mode_converter)
-             []
-             (info ["set-history-mode"] ~docs ~docv:"NODEPREFIX:MODE"
-                ~doc:
-                  "Set the history mode for a given (named) node, e.g. \
-                   `N000:archive`." ) ))
-end
diff --git a/vendors/flextesa-lib/tezos_node.mli b/vendors/flextesa-lib/tezos_node.mli
deleted file mode 100644
index 28de6f939bedb1a3810b9dce95e07052ff17f46b..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_node.mli
+++ /dev/null
@@ -1,90 +0,0 @@
-open Internal_pervasives
-
-type custom_network = [`Json of Ezjsonm.value]
-
-type t = private
-  { id: string
-  ; expected_connections: int
-  ; rpc_port: int
-  ; p2p_port: int
-  ; peers: int list
-  ; exec: Tezos_executable.t
-  ; protocol: Tezos_protocol.t
-  ; history_mode: [`Archive | `Full of int | `Rolling of int] option
-  ; single_process: bool
-  ; cors_origin: string option
-  ; custom_network: custom_network option }
-
-val compare : t -> t -> int
-val equal : t -> t -> bool
-val ef : t -> Easy_format.t
-val pp : t Fmt.t
-
-val make :
-     ?cors_origin:string
-  -> exec:Tezos_executable.t
-  -> ?protocol:Tezos_protocol.t
-  -> ?custom_network:[`Json of Ezjsonm.value]
-  -> ?single_process:bool
-  -> ?history_mode:[`Archive | `Full of int | `Rolling of int]
-  -> string
-  -> expected_connections:int
-  -> rpc_port:int
-  -> p2p_port:int
-  -> int list
-  -> t
-(** Create a node value (inert, not started), see
-   ["tezos-node run --help"] for corresponding parameters.
-
-- [?single_process]: defaults to [true] (for now since multi-process
-  validations still suffers from some bugs).
-- [?history_mode]: defaults to leaving the node's default (i.e. [`Full]).
-- [?cors_origin]: defaults to [Some "*"] (most permissive).
- *)
-
-val data_dir : < paths: Paths.t ; .. > -> t -> string
-val config_file : < paths: Paths.t ; .. > -> t -> string
-val identity_file : < paths: Paths.t ; .. > -> t -> string
-val log_output : < paths: Paths.t ; .. > -> t -> string
-val exec_path : < paths: Paths.t ; .. > -> t -> string
-
-val node_command :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> string list
-  -> string list
-  -> unit Genspio.Language.t
-
-val run_command :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> unit Genspio.Language.t
-
-val start_script :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> unit Genspio.Language.t
-
-val process :
-     < env_config: Environment_configuration.t ; paths: Paths.t ; .. >
-  -> t
-  -> Running_processes.Process.t
-
-val protocol : t -> Tezos_protocol.t
-
-val connections :
-  t list -> [`Duplex of t * t | `From_to of t * t | `Missing of t * int] list
-
-module History_modes : sig
-  type 'error edit = t list -> (t list, 'error) Asynchronous_result.t
-
-  val cmdliner_term :
-       < manpager: Manpage_builder.State.t ; .. >
-    -> [> System_error.t] edit Cmdliner.Term.t
-end
-
-module Config_file : sig
-  val network : ?genesis_hash:string -> unit -> (string * Ezjsonm.value) list
-  val default_network : (string * Ezjsonm.value) list
-  val of_node : < paths: Paths.t ; .. > -> t -> string
-end
diff --git a/vendors/flextesa-lib/tezos_protocol.ml b/vendors/flextesa-lib/tezos_protocol.ml
deleted file mode 100644
index 8c60e7392bdfbbbaa2973d36685367fe096b48d1..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_protocol.ml
+++ /dev/null
@@ -1,555 +0,0 @@
-open Internal_pervasives
-
-module Key = struct
-  module Of_name = struct
-    type t =
-      { name: string
-      ; pkh: Tezos_crypto.Ed25519.Public_key_hash.t
-      ; pk: Tezos_crypto.Ed25519.Public_key.t
-      ; sk: Tezos_crypto.Ed25519.Secret_key.t }
-
-    let make name =
-      let seed =
-        Bytes.of_string
-          (String.concat ~sep:"" (List.init 42 ~f:(fun _ -> name))) in
-      let pkh, pk, sk = Tezos_crypto.Ed25519.generate_key ~seed () in
-      {name; pkh; pk; sk}
-
-    let pubkey n = Tezos_crypto.Ed25519.Public_key.to_b58check (make n).pk
-
-    let pubkey_hash n =
-      Tezos_crypto.Ed25519.Public_key_hash.to_b58check (make n).pkh
-
-    let private_key n =
-      "unencrypted:" ^ Tezos_crypto.Ed25519.Secret_key.to_b58check (make n).sk
-  end
-end
-
-module Account = struct
-  type t =
-    | Of_name of string
-    | Key_pair of
-        {name: string; pubkey: string; pubkey_hash: string; private_key: string}
-
-  let of_name s = Of_name s
-  let of_namef fmt = ksprintf of_name fmt
-  let name = function Of_name n -> n | Key_pair k -> k.name
-
-  let key_pair name ~pubkey ~pubkey_hash ~private_key =
-    Key_pair {name; pubkey; pubkey_hash; private_key}
-
-  let pubkey = function
-    | Of_name n -> Key.Of_name.pubkey n
-    | Key_pair k -> k.pubkey
-
-  let pubkey_hash = function
-    | Of_name n -> Key.Of_name.pubkey_hash n
-    | Key_pair k -> k.pubkey_hash
-
-  let private_key = function
-    | Of_name n -> Key.Of_name.private_key n
-    | Key_pair k -> k.private_key
-end
-
-module Voting_period = struct
-  type t = [`Proposal | `Exploration | `Cooldown | `Promotion | `Adoption]
-end
-
-module Protocol_kind = struct
-  type t =
-    [ `Athens
-    | `Babylon
-    | `Carthage
-    | `Delphi
-    | `Edo
-    | `Florence
-    | `Granada
-    | `Hangzhou
-    | `Ithaca
-    | `Jakarta
-    | `Alpha ]
-
-  let names =
-    [ ("Athens", `Athens); ("Babylon", `Babylon); ("Carthage", `Carthage)
-    ; ("Delphi", `Delphi); ("Edo", `Edo); ("Florence", `Florence)
-    ; ("Granada", `Granada); ("Hangzhou", `Hangzhou); ("Ithaca", `Ithaca)
-    ; ("Jakarta", `Jakarta); ("Alpha", `Alpha) ]
-
-  let ( < ) k1 k2 =
-    let rec aux = function
-      | [] -> assert false
-      | (_, k) :: rest ->
-          if Poly.equal k k2 then false
-          else if Poly.equal k k1 then true
-          else aux rest in
-    aux names
-
-  let default = `Alpha
-
-  let cmdliner_term ~docs () : t Cmdliner.Term.t =
-    let open Cmdliner in
-    Arg.(
-      value
-        (opt (enum names) default
-           (info ["protocol-kind"] ~docs ~doc:"Set the protocol family.") ))
-
-  let pp ppf n =
-    Fmt.string ppf
-      (List.find_map_exn names ~f:(function
-        | s, x when Poly.equal x n -> Some s
-        | _ -> None ) )
-end
-
-type t =
-  { id: string
-  ; kind: Protocol_kind.t
-  ; bootstrap_accounts: (Account.t * Int64.t) list
-  ; dictator: Account.t
-  ; expected_pow: int
-  ; name: string (* e.g. alpha *)
-  ; hash: string
-  ; time_between_blocks: int list
-  ; minimal_block_delay: int
-  ; baking_reward_per_endorsement: int list
-  ; endorsement_reward: int list
-  ; blocks_per_roll_snapshot: int
-  ; blocks_per_voting_period: int
-  ; blocks_per_cycle: int
-  ; preserved_cycles: int
-  ; proof_of_work_threshold: int
-  ; timestamp_delay: int option
-  ; custom_protocol_parameters: Ezjsonm.t option }
-
-let compare a b = String.compare a.id b.id
-
-let make_bootstrap_accounts ~balance n =
-  List.init n ~f:(fun n -> (Account.of_namef "bootacc-%d" n, balance))
-
-let default () =
-  let dictator = Account.of_name "dictator-default" in
-  { id= "default-bootstrap"
-  ; kind= Protocol_kind.default
-  ; bootstrap_accounts= make_bootstrap_accounts ~balance:4_000_000_000_000L 4
-  ; dictator
-  ; expected_pow= 1
-  ; name= "alpha"
-  ; hash= "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
-  ; time_between_blocks= [2; 3]
-  ; minimal_block_delay= 2
-  ; baking_reward_per_endorsement= [78_125; 11_719]
-  ; endorsement_reward= [78_125; 52_083]
-  ; blocks_per_roll_snapshot= 4
-  ; blocks_per_voting_period= 16
-  ; blocks_per_cycle= 8
-  ; preserved_cycles= 2
-  ; proof_of_work_threshold= -1
-  ; timestamp_delay= None
-  ; custom_protocol_parameters= None }
-
-let extract_custom_parameter ~get ~key s =
-  let open Ezjsonm in
-  get_option (fun v -> get (find v [key])) (value s)
-
-let add_optional_parameter ~key ~to_value ~v s =
-  let open Ezjsonm in
-  match v with
-  | None -> s
-  | Some v ->
-      let d = get_dict (value s) in
-      dict ((key, to_value v) :: d)
-
-let remove_custom_parameter ~key s =
-  let open Ezjsonm in
-  let d = get_dict (value s) in
-  dict (List.filter d ~f:(fun (key', _) -> String.equal key key'))
-
-let protocol_parameters_json t : Ezjsonm.t =
-  let open Ezjsonm in
-  (* Because Alpha uses cycles_per_voting_period
-     instead of blocks_per_voting_period, we need to change `t.custom_parameter_type`
-     to convert `blocks_per_voting_period` to `cycles_per_voting_period`.
-     Note that if the `blocks_per_voting_period` is a custom parameter
-      but `blocks_per_cycle` is not, then we fallback to `default().blocks_per_cycle`
-     to compute the `cycles_per_voting_period`.
-  *)
-  let custom_parameters t =
-    match (t.custom_protocol_parameters, t.kind) with
-    | Some s, `Alpha ->
-        let blocks_per_voting_period =
-          extract_custom_parameter ~get:Ezjsonm.get_int
-            ~key:"blocks_per_voting_period" s in
-        let blocks_per_cycle =
-          match
-            extract_custom_parameter ~get:get_int ~key:"blocks_per_cycle" s
-          with
-          | None -> Some (default ()).blocks_per_cycle
-          | b -> b in
-        let cycles_per_voting_period =
-          Option.map2 blocks_per_voting_period blocks_per_cycle ~f:(fun a b ->
-              a / b ) in
-        let r = remove_custom_parameter ~key:"blocks_per_voting_period" s in
-        Some
-          (add_optional_parameter ~key:"cycles_per_voting_period"
-             ~to_value:Ezjsonm.int ~v:cycles_per_voting_period s )
-    | _, _ -> t.custom_protocol_parameters in
-  let make_account (account, amount) =
-    strings [Account.pubkey account; sprintf "%Ld" amount] in
-  let extra_post_babylon_stuff subkind =
-    let alpha_specific_parameters =
-      match subkind with
-      | `Alpha  ->
-          [ ("sc_rollup_enable", bool false)
-          ; ("sc_rollup_origination_size", int 6_314) ]
-      | `Ithaca | `Jakarta -> []
-      | _ -> failwith "unsupported protocol" in
-    let list_of_zs = list (fun i -> string (Int.to_string i)) in
-    let pre_alpha_specific_parameters =
-      match subkind with
-      | `Alpha ->
-          [("liquidity_baking_toggle_ema_threshold", int 1000000000)
-          ]
-      | `Ithaca ->
-          [("liquidity_baking_escape_ema_threshold", int 666667)
-          ]
-      | `Jakarta ->
-          [("tx_rollup_enable", bool true)
-          ]
-      | _ -> failwith "unsupported protocol" in
-    let pre_ithaca_specific_parameters =
-      match subkind with
-      | `Ithaca | `Jakarta | `Alpha ->
-          [ ("max_operations_time_to_live", int 120)
-          ; ("blocks_per_stake_snapshot", int t.blocks_per_roll_snapshot)
-          ; ("baking_reward_fixed_portion", string "10000000")
-          ; ("baking_reward_bonus_per_slot", string "4286")
-          ; ("endorsing_reward_per_slot", string "2857")
-          ; ("consensus_committee_size", int 67); ("consensus_threshold", int 6)
-          ; ( "minimal_participation_ratio"
-            , dict [("numerator", int 2); ("denominator", int 3)] )
-          ; ("minimal_block_delay", string (Int.to_string t.minimal_block_delay))
-          ; ("delay_increment_per_round", string "1")
-          ; ("max_slashing_period", int 2)
-          ; ("frozen_deposits_percentage", int 10)
-          ; ( "ratio_of_frozen_deposits_slashed_per_double_endorsement"
-            , dict [("numerator", int 1); ("denominator", int 2)] )
-          ; ("double_baking_punishment", string "640000000") ]
-      | _ -> failwith "unsupported protocol" in
-    let blocks_or_cycle_per_voting_period =
-      match subkind with
-      | `Jakarta | `Alpha ->
-          [ ( "cycles_per_voting_period"
-            , int (t.blocks_per_voting_period / t.blocks_per_cycle) ) ]
-      | `Ithaca ->
-          [("blocks_per_voting_period", int t.blocks_per_voting_period)]
-      | _ -> failwith "unsupported protocol" in
-    alpha_specific_parameters @ pre_alpha_specific_parameters @
-    pre_ithaca_specific_parameters @ blocks_or_cycle_per_voting_period in
-  let common =
-    [ ( "bootstrap_accounts"
-      , list make_account (t.bootstrap_accounts @ [(t.dictator, 10_000_000L)])
-      ); ("blocks_per_cycle", int t.blocks_per_cycle)
-    ; ("preserved_cycles", int t.preserved_cycles)
-    ; ("proof_of_work_threshold", ksprintf string "%d" t.proof_of_work_threshold)
-    ; ("blocks_per_commitment", int 4)
-    ; ("hard_gas_limit_per_operation", string (Int.to_string 1_040_000))
-    ; ("hard_gas_limit_per_block", string (Int.to_string 5_200_000))
-    ; ("tokens_per_roll", string (Int.to_string 8_000_000_000))
-    ; ("seed_nonce_revelation_tip", string (Int.to_string 125_000))
-    ; ("origination_size", int 257)
-    ; ("hard_storage_limit_per_operation", string (Int.to_string 60_000))
-    ; ("cost_per_byte", string (Int.to_string 250)); ("quorum_min", int 3_000)
-    ; ("quorum_max", int 7_000); ("min_proposal_quorum", int 500)
-    ; ("liquidity_baking_subsidy", string "2500000")
-    ; ("liquidity_baking_sunset_level", int 525600)
-    ] in
-  match custom_parameters t with
-  | Some s -> s
-  | None -> dict (common @ extra_post_babylon_stuff t.kind)
-
-let voting_period_to_string t (p : Voting_period.t) =
-  (* This has to mimic: src/proto_alpha/lib_protocol/voting_period_repr.ml *)
-  match p with
-  | `Promotion ->
-      if Protocol_kind.(t.kind < `Florence) then "promotion_vote"
-      else "promotion"
-  | `Exploration ->
-      if Protocol_kind.(t.kind < `Florence) then "testing_vote"
-      else "exploration"
-  | `Proposal -> "proposal"
-  | `Cooldown ->
-      if Protocol_kind.(t.kind < `Florence) then "testing" else "cooldown"
-  | `Adoption -> "adoption"
-
-let sandbox {dictator; _} =
-  let pk = Account.pubkey dictator in
-  Ezjsonm.to_string (`O [("genesis_pubkey", `String pk)])
-
-let protocol_parameters t =
-  Ezjsonm.to_string ~minify:false (protocol_parameters_json t)
-
-let expected_pow t = t.expected_pow
-let id t = t.id
-let kind t = t.kind
-let bootstrap_accounts t = List.map ~f:fst t.bootstrap_accounts
-let dictator_name {dictator; _} = Account.name dictator
-let dictator_secret_key {dictator; _} = Account.private_key dictator
-let make_path config t = Paths.root config // sprintf "protocol-%s" (id t)
-let sandbox_path config t = make_path config t // "sandbox.json"
-
-let protocol_parameters_path config t =
-  make_path config t // "protocol_parameters.json"
-
-let ensure_script state t =
-  let open Genspio.EDSL in
-  let file string p =
-    let path = p state t in
-    ( Caml.Filename.basename path
-    , write_stdout ~path:(str path)
-        (feed ~string:(str (string t)) (exec ["cat"])) ) in
-  check_sequence
-    ~verbosity:(`Announce (sprintf "Ensure-protocol-%s" (id t)))
-    [ ("directory", exec ["mkdir"; "-p"; make_path state t])
-    ; file sandbox sandbox_path
-    ; file protocol_parameters protocol_parameters_path ]
-
-let ensure state t =
-  Running_processes.run_successful_cmdf state "sh -c %s"
-    (Genspio.Compile.to_one_liner (ensure_script state t) |> Caml.Filename.quote)
-  >>= fun _ -> return ()
-
-let cli_term state =
-  let open Cmdliner in
-  let open Term in
-  let def = default () in
-  let docs = Manpage_builder.section state ~rank:2 ~name:"PROTOCOL OPTIONS" in
-  pure
-    (fun
-      bootstrap_accounts
-      (`Blocks_per_voting_period blocks_per_voting_period)
-      (`Protocol_hash hash)
-      (`Time_between_blocks time_between_blocks)
-      (`Minimal_block_delay minimal_block_delay)
-      (`Blocks_per_cycle blocks_per_cycle)
-      (`Preserved_cycles preserved_cycles)
-      (`Timestamp_delay timestamp_delay)
-      (`Protocol_parameters custom_protocol_parameters)
-      kind
-    ->
-      let id = "default-and-command-line" in
-      { def with
-        id
-      ; kind
-      ; custom_protocol_parameters
-      ; blocks_per_cycle
-      ; hash
-      ; bootstrap_accounts
-      ; time_between_blocks
-      ; minimal_block_delay
-      ; preserved_cycles
-      ; timestamp_delay
-      ; blocks_per_voting_period } )
-  $ Arg.(
-      pure (fun remove_all nb balance add_bootstraps ->
-          add_bootstraps
-          @ make_bootstrap_accounts ~balance (if remove_all then 0 else nb) )
-      $ value
-          (flag
-             (info
-                ~doc:
-                  "Do not create any of the default bootstrap accounts (this \
-                   overrides `--number-of-bootstrap-accounts` with 0)."
-                ~docs
-                ["remove-default-bootstrap-accounts"] ) )
-      $ value
-          (opt int 4
-             (info
-                ["number-of-bootstrap-accounts"]
-                ~docs ~doc:"Set the number of generated bootstrap accounts." ) )
-      $ ( pure (function
-            | `Tez, f -> f *. 1_000_000. |> Int64.of_float
-            | `Mutez, f -> f |> Int64.of_float )
-        $ value
-            (opt
-               (pair ~sep:':'
-                  (enum [("tz", `Tez); ("tez", `Tez); ("mutez", `Mutez)])
-                  float )
-               (`Tez, 4_000_000.)
-               (info
-                  ["balance-of-bootstrap-accounts"]
-                  ~docv:"UNIT:FLOAT" ~docs
-                  ~doc:
-                    "Set the initial balance of bootstrap accounts, for \
-                     instance: `tz:2_000_000.42` or \
-                     `mutez:42_000_000_000_000`." ) ) )
-      $ Arg.(
-          pure (fun l ->
-              List.map l
-                ~f:(fun ((name, pubkey, pubkey_hash, private_key), tez) ->
-                  (Account.key_pair name ~pubkey ~pubkey_hash ~private_key, tez) ) )
-          $ value
-              (opt_all
-                 (pair ~sep:'@' (t4 ~sep:',' string string string string) int64)
-                 []
-                 (info ["add-bootstrap-account"] ~docs
-                    ~docv:"NAME,PUBKEY,PUBKEY-HASH,PRIVATE-URI@MUTEZ-AMOUNT"
-                    ~doc:
-                      "Add a custom bootstrap account, e.g. \
-                       `LedgerBaker,edpku...,tz1YPS...,ledger://crouching-tiger.../ed25519/0'/0'@20_000_000_000`." ) )))
-  $ Arg.(
-      pure (fun x -> `Blocks_per_voting_period x)
-      $ value
-          (opt int def.blocks_per_voting_period
-             (info ~docs
-                ["blocks-per-voting-period"]
-                ~doc:"Set the length of voting periods." ) ))
-  $ Arg.(
-      pure (fun x -> `Protocol_hash x)
-      $ value
-          (opt string def.hash
-             (info ["protocol-hash"] ~docs
-                ~doc:"Set the (initial) protocol hash." ) ))
-  $ Arg.(
-      pure (fun x -> `Time_between_blocks x)
-      $ value
-          (opt (list ~sep:',' int) def.time_between_blocks
-             (info ["time-between-blocks"] ~docv:"COMMA-SEPARATED-SECONDS" ~docs
-                ~doc:
-                  "Set the time between blocks bootstrap-parameter, e.g. \
-                   `2,3,2`." ) ))
-  $ Arg.(
-      pure (fun x -> `Minimal_block_delay x)
-      $ value
-          (opt int def.minimal_block_delay
-             (info ["minimal-block-delay"] ~docv:"SECONDS" ~docs
-                ~doc:
-                  "Set the minimal delay between blocks bootstrap-parameter, \
-                   e.g. `2`." ) ))
-  $ Arg.(
-      pure (fun x -> `Blocks_per_cycle x)
-      $ value
-          (opt int def.blocks_per_cycle
-             (info ["blocks-per-cycle"] ~docv:"NUMBER" ~docs
-                ~doc:"Number of blocks per cycle." ) ))
-  $ Arg.(
-      pure (fun x -> `Preserved_cycles x)
-      $ value
-          (opt int def.preserved_cycles
-             (info ["preserved-cycles"] ~docv:"NUMBER" ~docs
-                ~doc:
-                  "Base constant for baking rights (search for \
-                   `PRESERVED_CYCLES` in the white paper)." ) ))
-  $ Arg.(
-      pure (fun x -> `Timestamp_delay x)
-      $ value
-          (opt (some int) def.timestamp_delay
-             (info ["timestamp-delay"] ~docv:"NUMBER" ~docs
-                ~doc:"Protocol activation timestamp delay in seconds." ) ))
-  $ Arg.(
-      pure (fun f ->
-          `Protocol_parameters
-            (Option.map f ~f:(fun path ->
-                 let i = Caml.open_in path in
-                 Ezjsonm.from_channel i ) ) )
-      $ value
-          (opt (some file) None
-             (info
-                ["override-protocol-parameters"]
-                ~doc:
-                  "Use these protocol parameters instead of the generated ones \
-                   (technically this invalidates most other options from a \
-                   tezos-node point of view, use at your own risk)."
-                ~docv:"JSON-FILE" ~docs ) ))
-  $ Protocol_kind.cmdliner_term () ~docs
-
-module Pretty_print = struct
-  open More_fmt
-
-  let verbatim_protection f ppf json_blob =
-    try f ppf json_blob with e -> json ppf json_blob ; cut ppf () ; exn ppf e
-
-  let fail_expecting s = failwith "PP: Expecting %s" s
-
-  let mempool_pending_operations_rpc ppf mempool_json =
-    let pp_op_list_short ppf l =
-      let kinds =
-        List.map l ~f:(fun js -> Jqo.(field ~k:"kind" js |> get_string)) in
-      pf ppf "%s"
-        ( List.fold kinds ~init:[] ~f:(fun prev k ->
-              match prev with
-              | (kind, n) :: more when String.equal kind k ->
-                  (kind, n + 1) :: more
-              | other -> (k, 1) :: other )
-        |> List.map ~f:(function k, 1 -> k | k, n -> str "%s×%d" k n)
-        |> String.concat ~sep:"+" ) in
-    let open Jqo in
-    match mempool_json with
-    | `O four_fields ->
-        List.iter four_fields ~f:(fun (name, content) ->
-            pf ppf "@,* `%s`: " (String.capitalize name) ;
-            match content with
-            | `A [] -> pf ppf "Empty."
-            | `A l -> (
-              match name with
-              | "applied" ->
-                  List.iter l ~f:(fun op ->
-                      let contents = field ~k:"contents" op |> get_list in
-                      let pp_op_long ppf js =
-                        match field ~k:"kind" js |> get_string with
-                        | "transaction" ->
-                            pf ppf "@,       * Mutez:%s: `%s` -> `%s`%s"
-                              (field ~k:"amount" js |> get_string)
-                              (field ~k:"source" js |> get_string)
-                              (field ~k:"destination" js |> get_string)
-                              ( try
-                                  let _ = field ~k:"parameters" js in
-                                  "+parameters"
-                                with _ -> "" )
-                        | "origination" ->
-                            pf ppf
-                              "@,       * Mutez:%s, source: `%s`, fee: `%s`"
-                              (field ~k:"balance" js |> get_string)
-                              (field ~k:"source" js |> get_string)
-                              (field ~k:"fee" js |> get_string)
-                        | _ -> () in
-                      pf ppf "@,   * [%a] %a" pp_op_list_short contents
-                        (long_string ~max:15)
-                        (field ~k:"hash" op |> get_string) ;
-                      List.iter contents ~f:(pp_op_long ppf) )
-              | _other ->
-                  List.iter l ~f:(function
-                    | `A [`String opid; op] ->
-                        let contents = field ~k:"contents" op |> get_list in
-                        pf ppf "@,    * [%s]: %a" opid pp_op_list_short contents ;
-                        pf ppf "@,    TODO: %a" json content
-                    | _ -> fail_expecting "a operation tuple" ) )
-            | _ -> fail_expecting "a list of operations" )
-    | _ -> fail_expecting "a JSON object"
-
-  let block_head_rpc ppf block_json =
-    let open Jqo in
-    let proto = field ~k:"protocol" block_json |> get_string in
-    let hash = field ~k:"hash" block_json |> get_string in
-    let metadata = field ~k:"metadata" block_json in
-    let next_protocol = metadata |> field ~k:"next_protocol" |> get_string in
-    let header = field ~k:"header" block_json in
-    let level = field ~k:"level" header |> get_int in
-    let timestamp = field ~k:"timestamp" header |> get_string in
-    let voting_kind =
-      metadata
-      |> field ~k:"voting_period_info"
-      |> field ~k:"voting_period" |> field ~k:"kind" |> get_string in
-    let voting_pos =
-      metadata
-      |> field ~k:"voting_period_info"
-      |> field ~k:"position" |> get_int in
-    let voting_nth =
-      metadata |> field ~k:"level" |> field ~k:"voting_period" |> get_int in
-    let baker = metadata |> field ~k:"baker" |> get_string in
-    pf ppf "Level %d | `%s` | %s" level hash timestamp ;
-    pf ppf "@,* Protocol: `%s`" proto ;
-    if String.equal proto next_protocol then pf ppf " (also next)"
-    else pf ppf "@,* Next-protocol: `%s`" next_protocol ;
-    pf ppf "@,* Voting period %d: `%s` (level: %d)" voting_nth voting_kind
-      voting_pos ;
-    pf ppf "@,* Baker: `%s`" baker
-end
diff --git a/vendors/flextesa-lib/tezos_protocol.mli b/vendors/flextesa-lib/tezos_protocol.mli
deleted file mode 100644
index 2ae336da36334942c1e18190b73a7ee52cd4e8e6..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/tezos_protocol.mli
+++ /dev/null
@@ -1,112 +0,0 @@
-(** Create and manipulate bootstrap-parameters and accounts. *)
-
-open Internal_pervasives
-
-(** Manipulate public/private key pairs. *)
-module Key : sig
-  (** Deterministically generate public/private key (hashes) from
-      given strings. *)
-  module Of_name : sig
-    val pubkey : string -> string
-    val pubkey_hash : string -> string
-    val private_key : string -> string
-  end
-end
-
-(** An account is a named key-pair. *)
-module Account : sig
-  type t = private
-    | Of_name of string
-    | Key_pair of
-        {name: string; pubkey: string; pubkey_hash: string; private_key: string}
-
-  val of_name : string -> t
-  val of_namef : ('a, unit, string, t) format4 -> 'a
-
-  val key_pair :
-    string -> pubkey:string -> pubkey_hash:string -> private_key:string -> t
-
-  val name : t -> string
-  val pubkey : t -> string
-  val pubkey_hash : t -> string
-  val private_key : t -> string
-end
-
-module Voting_period : sig
-  type t =
-    [ `Proposal
-    | `Exploration
-    | `Cooldown
-    | `Promotion
-    | `Adoption ]
-end
-
-module Protocol_kind : sig
-  type t = [`Athens | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada | `Hangzhou | `Ithaca | `Jakarta | `Alpha]
-
-  val names : (string * t) list
-  val cmdliner_term : docs:string -> unit -> t Cmdliner.Term.t
-  val pp : t Fmt.t
-end
-
-(** [t] wraps bootstrap parameters for sandboxed protocols. *)
-type t =
-  { id: string
-  ; kind: Protocol_kind.t
-  ; bootstrap_accounts: (Account.t * Int64.t) list
-  ; dictator: Account.t
-        (* ; bootstrap_contracts: (Account.t * int * Script.origin) list *)
-  ; expected_pow: int
-  ; name: string
-  ; hash: string
-  ; time_between_blocks: int list
-  ; minimal_block_delay: int
-  ; baking_reward_per_endorsement: int list
-  ; endorsement_reward: int list
-  ; blocks_per_roll_snapshot: int
-  ; blocks_per_voting_period: int
-  ; blocks_per_cycle: int
-  ; preserved_cycles: int
-  ; proof_of_work_threshold: int
-  ; timestamp_delay: int option
-  ; custom_protocol_parameters: Ezjsonm.t option }
-
-val compare : t -> t -> int
-val default : unit -> t
-val protocol_parameters_json : t -> Ezjsonm.t
-val sandbox : t -> string
-val protocol_parameters : t -> string
-val voting_period_to_string : t -> Voting_period.t -> string
-val expected_pow : t -> int
-val id : t -> string
-val bootstrap_accounts : t -> Account.t list
-val kind : t -> Protocol_kind.t
-val dictator_name : t -> string
-val dictator_secret_key : t -> string
-val sandbox_path : < paths: Paths.t ; .. > -> t -> string
-val protocol_parameters_path : < paths: Paths.t ; .. > -> t -> string
-
-val ensure_script : < paths: Paths.t ; .. > -> t -> unit Genspio.Language.t
-(** Build a {!Genspio.EDSL.t} script which generates the
-    bootstrap-parameters JSON file. *)
-
-val ensure :
-     < application_name: string
-     ; paths: Paths.t
-     ; runner: Running_processes.State.t
-     ; .. >
-  -> t
-  -> (unit, [> System_error.t | Process_result.Error.t]) Asynchronous_result.t
-(** Run the script created by [ensure_script], i.e. create the JSON
-    bootstrap parameters. *)
-
-val cli_term : < manpager: Manpage_builder.State.t ; .. > -> t Cmdliner.Term.t
-(** Create a [Cmdliner] term which configures protocol-parameters
-    (e.g. options like ["--time-between-blocks"]). *)
-
-(** Pretty-printers for protocol-dependent things (e.g. RPC JSON blobs). *)
-module Pretty_print : sig
-  val verbatim_protection : Ezjsonm.value Fmt.t -> Ezjsonm.value Fmt.t
-  val mempool_pending_operations_rpc : Ezjsonm.value Fmt.t
-  val block_head_rpc : Ezjsonm.value Fmt.t
-end
diff --git a/vendors/flextesa-lib/traffic_generation.ml b/vendors/flextesa-lib/traffic_generation.ml
deleted file mode 100644
index 602c4bcc06dd3f3f43592aabbde9a546f879113f..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/traffic_generation.ml
+++ /dev/null
@@ -1,156 +0,0 @@
-open Internal_pervasives
-
-module Michelson = struct
-  let prepare_origination_of_id_script ?delegate ?(push_drops = 0)
-      ?(amount = "2") state ~name ~from ~protocol_kind ~parameter ~init_storage
-      =
-    let id_script parameter =
-      Fmt.str
-        "parameter %s;\n\
-         storage %s;\n\
-         code\n\
-        \  {\n\
-        \    %s\n\
-        \    { CAR; NIL operation; PAIR }\n\
-        \  };\n"
-        parameter parameter
-        ( match push_drops with
-        | 0 -> "# No push-drops"
-        | n ->
-            Fmt.str "# %d push-drop%s\n    %s" n
-              (if n > 1 then "s" else "")
-              ( List.init push_drops ~f:(fun ith ->
-                    Fmt.str "{ PUSH string %S ; DROP } ;"
-                      (Fmt.str
-                         "push-dropping %d adds stupid bytes to the contract"
-                         ith))
-              |> String.concat ~sep:"\n    " ) ) in
-    let tmp = Caml.Filename.temp_file "little-id-script" ".tz" in
-    System.write_file state tmp ~content:(id_script parameter)
-    >>= fun () ->
-    Dbg.e EF.(wf "id_script %s: %s" parameter tmp) ;
-    let origination =
-      let opt = Option.value_map ~default:[] in
-      ["--wait"; "none"; "originate"; "contract"; name]
-      @ ( match protocol_kind with
-        | `Athens -> ["for"; from]
-        | `Babylon | `Carthage | `Delphi | `Edo | `Florence | `Granada | `Hangzhou | `Ithaca | `Jakarta | `Alpha -> [] )
-      @ [ "transferring"; amount; "from"; from; "running"; tmp; "--init"
-        ; init_storage; "--force"; "--burn-cap"; "300000000000"
-        ; (* ; "--fee-cap" ; "20000000000000" *) "--gas-limit"
-        ; "1000000000000000"; "--storage-limit"; "20000000000000"
-        ; "--verbose-signing" ]
-      @ opt delegate ~f:(fun s -> (* Baby & Aths *) ["--delegate"; s]) in
-    return origination
-end
-
-module Random = struct
-  let run state ~protocol ~nodes ~clients ~until_level kind =
-    assert (Poly.equal kind `Any) ;
-    let tbb =
-      protocol.Tezos_protocol.time_between_blocks |> List.hd
-      |> Option.value ~default:10 in
-    let info fmt =
-      Fmt.kstr
-        (fun s ->
-          Console.sayf state Fmt.(fun ppf () -> pf ppf "Randomizer: %s" s))
-        fmt in
-    let from = "bootacc-0" in
-    let client = List.hd_exn clients in
-    let pp_success ppf = function
-      | true -> Fmt.pf ppf "Success"
-      | false -> Fmt.pf ppf "Failure" in
-    let valid_contracts = ref [] in
-    let rec loop iteration =
-      let client_cmd name l =
-        Tezos_client.client_cmd ~verbose:false state ~client
-          ~id_prefix:(Fmt.str "randomizer-%04d-%s" iteration name)
-          l in
-      let continue_or_not () =
-        Test_scenario.Queries.all_levels state ~nodes
-        >>= fun all_levels ->
-        if
-          List.for_all all_levels ~f:(function
-            | _, `Level l when l >= until_level -> true
-            | _ -> false)
-        then info "Max-level reached: %d" until_level
-        else loop (iteration + 1) in
-      List.random_element [`Sleep; `Add_contract; `Call_contract]
-      |> function
-      | Some `Sleep ->
-          let secs =
-            Float.(Random.float_range (of_int tbb * 0.3) (of_int tbb * 1.5))
-          in
-          info "Sleeping %.2f seconds." secs
-          >>= fun () -> System.sleep secs >>= fun () -> continue_or_not ()
-      | Some `Call_contract ->
-          ( match List.random_element !valid_contracts with
-          | None -> info "No valid contracts to call."
-          | Some (name, params) ->
-              client_cmd
-                (Fmt.str "transfer-%s" name)
-                ["transfer"; "1"; "from"; from; "to"; name; "--arg"; params]
-              >>= fun (success, _) ->
-              info "Called %s(%s): %a" name params pp_success success )
-          >>= fun () -> continue_or_not ()
-      | Some `Add_contract ->
-          let name = Fmt.str "contract-%d" iteration in
-          let push_drops = Random.int 100 in
-          let parameter, init_storage =
-            match List.random_element [`Unit; `String] with
-            | Some `String ->
-                ( "string"
-                , Fmt.str "%S"
-                    (String.init
-                       (Random.int 42 + 1)
-                       ~f:(fun _ -> Random.int 20 + 40 |> Char.of_int_exn)) )
-            | _ -> ("unit", "Unit") in
-          Michelson.prepare_origination_of_id_script state ~name ~from
-            ~protocol_kind:protocol.Tezos_protocol.kind ~parameter
-            ~init_storage ~push_drops
-          >>= fun origination ->
-          client_cmd (Fmt.str "originate-%s" name) origination
-          >>= fun (success, _) ->
-          if success then
-            valid_contracts := (name, init_storage) :: !valid_contracts ;
-          info "Origination of `%s` (%s : %s): `%a`." name init_storage
-            parameter pp_success success
-          >>= fun () -> continue_or_not ()
-      | None -> continue_or_not () in
-    loop 0
-end
-
-module Forge = struct
-  let batch_transfer
-      ?(protocol_kind : Tezos_protocol.Protocol_kind.t = `Babylon)
-      ?(counter = 0) ?(dst = [("tz2KZPgf2rshxNUBXFcTaCemik1LH1v9qz3F", 1)])
-      ~src ~fee ~branch n : Ezjsonm.value =
-    let open Ezjsonm in
-    ignore protocol_kind ;
-    dict
-      [ ("branch", `String branch)
-      ; ( "contents"
-        , `A
-            (List.map (List.range 0 n) ~f:(fun i ->
-                 let dest, amount = List.nth_exn dst (i % List.length dst) in
-                 `O
-                   [ ("kind", `String "transaction")
-                   ; ("source", `String src)
-                   ; ("destination", `String dest)
-                   ; ("amount", `String (Int.to_string amount))
-                   ; ( "fee"
-                     , `String (Int.to_string (Float.to_int (fee *. 1000000.)))
-                     )
-                   ; ("counter", `String (Int.to_string (counter + i)))
-                   ; ("gas_limit", `String (Int.to_string 127))
-                   ; ("storage_limit", `String (Int.to_string 277)) ])) ) ]
-
-  let endorsement ?(protocol_kind : Tezos_protocol.Protocol_kind.t = `Babylon)
-      ~branch level : Ezjsonm.value =
-    let open Ezjsonm in
-    ignore protocol_kind ;
-    dict
-      [ ("branch", `String branch)
-      ; ( "contents"
-        , `A [`O [("kind", `String "endorsement"); ("level", int level)]] ) ]
-end
diff --git a/vendors/flextesa-lib/traffic_generation.mli b/vendors/flextesa-lib/traffic_generation.mli
deleted file mode 100644
index b19f342032a7684fc4551c5bebb72b8a7b56aec0..0000000000000000000000000000000000000000
--- a/vendors/flextesa-lib/traffic_generation.mli
+++ /dev/null
@@ -1,51 +0,0 @@
-open Internal_pervasives
-
-(** Helpers to generate traffic in sandboxes. *)
-
-module Michelson : sig
-  val prepare_origination_of_id_script :
-       ?delegate:string
-    -> ?push_drops:int
-    -> ?amount:string
-    -> < application_name: string ; .. >
-    -> name:string
-    -> from:string
-    -> protocol_kind:Tezos_protocol.Protocol_kind.t
-    -> parameter:string
-    -> init_storage:string
-    -> (string list, [> System_error.t]) Asynchronous_result.t
-end
-
-module Random : sig
-  val run :
-       < application_name: string
-       ; console: Console.t
-       ; env_config: Environment_configuration.t
-       ; paths: Paths.t
-       ; runner: Running_processes.State.t
-       ; .. >
-    -> protocol:Tezos_protocol.t
-    -> nodes:Tezos_node.t list
-    -> clients:Tezos_client.t list
-    -> until_level:int
-    -> [> `Any]
-    -> (unit, [> System_error.t]) Asynchronous_result.t
-end
-
-module Forge : sig
-  val batch_transfer :
-       ?protocol_kind:Tezos_protocol.Protocol_kind.t
-    -> ?counter:int
-    -> ?dst:(string * int) list
-    -> src:string
-    -> fee:float
-    -> branch:string
-    -> int
-    -> Ezjsonm.value
-
-  val endorsement :
-       ?protocol_kind:Tezos_protocol.Protocol_kind.t
-    -> branch:string
-    -> int
-    -> Ezjsonm.value
-end