revert: add op-signer support (#207)

README.md

@@ -441,17 +441,6 @@ optimism_package:
         # Interval between submitting L2 output proposals
         proposal_internal: 10m
 
-      # Default signer configuration
-      signer_params:
-        # The Docker image that should be used for the signer; leave blank to use the default image
-        image: us-docker.pkg.dev/oplabs-tools-artifacts/images/op-signer
-
-        # The Docker tag that should be used for the signer; leave blank to use the default tag
-        tag: ""
-
-        # A list of optional extra params that will be passed to the signer container for modifying its behaviour
-        extra_params: []
-
       # Default MEV configuration
       mev_params:
         # The Docker image that should be used for rollup boost; leave blank to use the default rollup-boost image

justfile

@@ -20,6 +20,3 @@ lint:
         --checked-calls \
         --local-imports \
         main.star src/ test/
-
-test:
-    mise exec -- kurtosis-test .

main.star

@@ -107,6 +107,7 @@ def run(plan, args={}):
             l2_launcher.launch_l2(
                 plan,
                 l2_num,
+                chain.network_params.name,
                 chain,
                 jwt_file,
                 deployment_output,
@@ -133,6 +134,30 @@ def run(plan, args={}):
             observability_helper,
         )
 
+    # challenger must launch after supervisor because it depends on it for interop
+    for l2_num, l2 in enumerate(l2s):
+        chain = optimism_args.chains[l2_num]
+        op_challenger_image = (
+            chain.challenger_params.image
+            if chain.challenger_params.image != ""
+            else input_parser.DEFAULT_CHALLENGER_IMAGES["op-challenger"]
+        )
+        if chain.challenger_params.enabled:
+            op_challenger_launcher.launch(
+                plan,
+                l2_num,
+                "op-challenger-{0}".format(chain.network_params.name),
+                chain.challenger_params.image,
+                l2.participants[0].el_context,
+                l2.participants[0].cl_context,
+                l1_config_env_vars,
+                deployment_output,
+                chain.network_params,
+                chain.challenger_params,
+                interop_params,
+                observability_helper,
+            )
+
     observability.launch(
         plan, observability_helper, global_node_selectors, observability_params
     )

src/alt-da/da-server/da_server_launcher.star

@@ -25,14 +25,13 @@ def get_used_ports():
 
 def launch_da_server(
     plan,
+    service_name,
     image,
     cmd,
-    network_params,
 ):
-    service_name = "da-server-{0}".format(network_params.name)
-
     config = get_da_server_config(
         plan,
+        service_name,
         image,
         cmd,
     )
@@ -50,6 +49,7 @@ def launch_da_server(
 
 def get_da_server_config(
     plan,
+    service_name,
     image,
     cmd,
 ):

src/batcher/op-batcher/op_batcher_launcher.star

@@ -6,27 +6,25 @@ ethereum_package_constants = import_module(
     "github.com/ethpandaops/ethereum-package/src/package_io/constants.star"
 )
 
-input_parser = import_module("../../package_io/input_parser.star")
 constants = import_module("../../package_io/constants.star")
 util = import_module("../../util.star")
 
 observability = import_module("../../observability/observability.star")
-op_signer_launcher = import_module("../../signer/op_signer_launcher.star")
+prometheus = import_module("../../observability/prometheus/prometheus_launcher.star")
 
 #
 #  ---------------------------------- Batcher client -------------------------------------
-
-SERVICE_TYPE = "batcher"
-SERVICE_NAME = util.make_op_service_name(SERVICE_TYPE)
+# The Docker container runs as the "op-batcher" user so we can't write to root
+BATCHER_DATA_DIRPATH_ON_SERVICE_CONTAINER = "/data/op-batcher/op-batcher-data"
 
 # Port nums
-HTTP_PORT_NUM = 8548
+BATCHER_HTTP_PORT_NUM = 8548
 
 
 def get_used_ports():
     used_ports = {
         constants.HTTP_PORT_ID: ethereum_package_shared_utils.new_port_spec(
-            HTTP_PORT_NUM,
+            BATCHER_HTTP_PORT_NUM,
             ethereum_package_shared_utils.TCP_PROTOCOL,
             ethereum_package_shared_utils.HTTP_APPLICATION_PROTOCOL,
         ),
@@ -39,64 +37,69 @@ ENTRYPOINT_ARGS = ["sh", "-c"]
 
 def launch(
     plan,
+    service_name,
+    image,
     el_context,
     cl_context,
     l1_config_env_vars,
-    signer_context,
+    gs_batcher_private_key,
     batcher_params,
     network_params,
     observability_helper,
     da_server_context,
 ):
-    service_instance_name = util.make_service_instance_name(
-        SERVICE_NAME, network_params
+    config = get_batcher_config(
+        plan,
+        image,
+        service_name,
+        el_context,
+        cl_context,
+        l1_config_env_vars,
+        gs_batcher_private_key,
+        batcher_params,
+        observability_helper,
+        da_server_context,
     )
 
-    service = plan.add_service(
-        service_instance_name,
-        make_service_config(
-            plan,
-            el_context,
-            cl_context,
-            l1_config_env_vars,
-            signer_context,
-            batcher_params,
-            observability_helper,
-            da_server_context,
-        ),
-    )
+    service = plan.add_service(service_name, config)
+    service_url = util.make_service_http_url(service)
 
     observability.register_op_service_metrics_job(
         observability_helper, service, network_params.network
     )
 
-    return service
+    return service_url
 
 
-def make_service_config(
+def get_batcher_config(
     plan,
+    image,
+    service_name,
     el_context,
     cl_context,
     l1_config_env_vars,
-    signer_context,
+    gs_batcher_private_key,
     batcher_params,
     observability_helper,
     da_server_context,
 ):
     ports = dict(get_used_ports())
 
     cmd = [
-        SERVICE_NAME,
+        "op-batcher",
         "--l2-eth-rpc=" + el_context.rpc_http_url,
         "--rollup-rpc=" + cl_context.beacon_http_url,
         "--poll-interval=1s",
         "--sub-safety-margin=6",
         "--num-confirmations=1",
         "--safe-abort-nonce-too-low-count=3",
         "--resubmission-timeout=30s",
+        "--rpc.addr=0.0.0.0",
+        "--rpc.port=" + str(BATCHER_HTTP_PORT_NUM),
+        "--rpc.enable-admin",
         "--max-channel-duration=1",
         "--l1-eth-rpc=" + l1_config_env_vars["L1_RPC_URL"],
-        "--private-key=" + signer_context.clients[SERVICE_TYPE].key,
+        "--private-key=" + gs_batcher_private_key,
         # da commitments currently have to be sent as calldata to the batcher inbox
         "--data-availability-type="
         + ("calldata" if da_server_context.enabled else "blobs"),
@@ -107,29 +110,16 @@ def make_service_config(
         "--altda.da-service",
     ]
 
-    files = {}
-
     # apply customizations
 
-    util.configure_op_service_rpc(cmd, HTTP_PORT_NUM)
-    op_signer_launcher.configure_op_signer(cmd, files, signer_context, SERVICE_TYPE)
-
     if observability_helper.enabled:
         observability.configure_op_service_metrics(cmd, ports)
 
     cmd += batcher_params.extra_params
 
-    # legacy default image logic
-    image = (
-        batcher_params.image
-        if batcher_params.image != ""
-        else input_parser.DEFAULT_BATCHER_IMAGES[SERVICE_NAME]
-    )
-
     return ServiceConfig(
         image=image,
         ports=ports,
         cmd=cmd,
-        files=files,
         private_ip_address_placeholder=ethereum_package_constants.PRIVATE_IP_ADDRESS_PLACEHOLDER,
     )

src/blockscout/blockscout_launcher.star

@@ -44,6 +44,7 @@ VERIF_USED_PORTS = {
 
 def launch_blockscout(
     plan,
+    l2_services_suffix,
     l1_rpc_url,
     l2_el_context,
     l2_network_name,
@@ -60,13 +61,17 @@ def launch_blockscout(
 
     postgres_output = postgres.run(
         plan,
-        service_name="{0}-postgres{1}".format(SERVICE_NAME_BLOCKSCOUT, l2_network_name),
+        service_name="{0}-postgres{1}".format(
+            SERVICE_NAME_BLOCKSCOUT, l2_services_suffix
+        ),
         database="blockscout",
         extra_configs=["max_connections=1000"],
     )
 
     config_verif = get_config_verif()
-    verif_service_name = "{0}-verif{1}".format(SERVICE_NAME_BLOCKSCOUT, l2_network_name)
+    verif_service_name = "{0}-verif{1}".format(
+        SERVICE_NAME_BLOCKSCOUT, l2_services_suffix
+    )
     verif_service = plan.add_service(verif_service_name, config_verif)
     verif_url = "http://{}:{}".format(
         verif_service.hostname, verif_service.ports["http"].number
@@ -88,7 +93,7 @@ def launch_blockscout(
         },
     )
     blockscout_service = plan.add_service(
-        "{0}{1}".format(SERVICE_NAME_BLOCKSCOUT, l2_network_name), config_backend
+        "{0}{1}".format(SERVICE_NAME_BLOCKSCOUT, l2_services_suffix), config_backend
     )
     plan.print(blockscout_service)