Deploy OP Stack onto sequencer docker compose

.gitignore

@@ -20,6 +20,7 @@ cache
 packages/contracts-bedrock/deployments/devnetL1
 packages/contracts-bedrock/deployments/devnetL1-espresso
 packages/contracts-bedrock/deployments/devnetL1-espresso2
+packages/contracts-bedrock/deployments/espresso-demo
 packages/contracts-bedrock/deployments/anvil
 
 # vim
@@ -38,6 +39,7 @@ packages/contracts-bedrock/deployments/anvil
 .devnet
 .devnet-espresso
 .devnet-espresso2
+.espresso-demo
 
 # Ignore local fuzzing results
 **/testdata/fuzz/

Makefile

@@ -3,6 +3,7 @@ ITESTS_L2_HOST=http://localhost:9545
 BEDROCK_TAGS_REMOTE?=origin
 DEVNET_ESPRESSO_FLAGS=--espresso --deploy-config="devnetL1-espresso.json" --deploy-config-template="devnetL1-espresso-template.json" --deployment="devnetL1-espresso" --devnet-dir=".devnet-espresso" --l2-provider-url="http://localhost:19090"
 DEVNET_ESPRESSO_OP2_FLAGS=--espresso --deploy-config="devnetL1-espresso2.json" --deploy-config-template="devnetL1-espresso2-template.json" --deployment="devnetL1-espresso2" --devnet-dir=".devnet-espresso2" --l2-provider-url="http://localhost:29090" --faucet-url="http://localhost:28111" --l2="op2"
+DEVNET_ESPRESSO_DEMO_FLAGS=--espresso --deploy-config="espresso-demo.json" --deploy-config-template="espresso-demo-template.json" --deployment="espresso-demo" --devnet-dir=".espresso-demo" --l2-provider-url="http://localhost:19090" --l2="op" --compose-file "demo-docker-compose.yml" --faucet-url="http://localhost:28111"
 monorepo-base := $(realpath .)
 
 build: build-go build-ts
@@ -122,6 +123,10 @@ devnet-up-espresso2:
 	PYTHONPATH=./bedrock-devnet python3 ./bedrock-devnet/main.py --monorepo-dir=. $(DEVNET_ESPRESSO_OP2_FLAGS) --deploy-l2
 .PHONY: devnet-up-espresso2
 
+devnet-up-espresso-demo:
+	PYTHONPATH=./bedrock-devnet python3 ./bedrock-devnet/main.py --monorepo-dir=. $(DEVNET_ESPRESSO_DEMO_FLAGS) --deploy-l2
+.PHONY: devnet-up-espresso-demo
+
 # alias for devnet-up
 devnet-up-deploy: devnet-up
 
@@ -137,6 +142,10 @@ devnet-test-espresso2:
 	PYTHONPATH=./bedrock-devnet python3 ./bedrock-devnet/main.py --monorepo-dir=. $(DEVNET_ESPRESSO_OP2_FLAGS) --test
 .PHONY: devnet-test-espresso2
 
+devnet-test-espresso-demo:
+	PYTHONPATH=./bedrock-devnet python3 ./bedrock-devnet/main.py --monorepo-dir=. $(DEVNET_ESPRESSO_DEMO_FLAGS) --test
+.PHONY: devnet-test-espresso-demo
+
 devnet-down:
 	@(cd ./ops-bedrock && GENESIS_TIMESTAMP=$(shell date +%s) docker compose down -v)
 .PHONY: devnet-down
@@ -145,9 +154,11 @@ devnet-clean:
 	rm -rf ./packages/contracts-bedrock/deployments/devnetL1
 	rm -rf ./packages/contracts-bedrock/deployments/devnetL1-espresso
 	rm -rf ./packages/contracts-bedrock/deployments/devnetL1-espresso2
+	rm -rf ./packages/contracts-bedrock/deployments/espresso-demo
 	rm -rf ./.devnet
 	rm -rf ./.devnet-espresso
 	rm -rf ./.devnet-espresso2
+	rm -rf ./.espresso-demo
 	cd ./ops-bedrock && docker compose down -v
 	docker image ls 'ops-bedrock*' --format='{{.Repository}}' | xargs -r docker rmi
 	docker volume ls --filter name=ops-bedrock --format='{{.Name}}' | xargs -r docker volume rm

bedrock-devnet/devnet/__init__.py

@@ -28,6 +28,7 @@
 parser.add_argument('--deployment', help='Path to deployment output files, relative to packages/contracts-bedrock/deployments', default='devnetL1')
 parser.add_argument('--devnet-dir', help='Output path for devnet config, relative to --monorepo-dir', default='.devnet')
 parser.add_argument('--espresso', help='Run on Espresso Sequencer', type=bool, action=argparse.BooleanOptionalAction)
+parser.add_argument("--compose-file", help="Compose file to use for demo images", type=str, default="docker-compose.yml")
 
 log = logging.getLogger()
 
@@ -119,9 +120,14 @@ def deploy_contracts(paths, deploy_config: str, deploy_l2: bool):
     account = response['result'][0]
     log.info(f'Deploying with {account}')
 
-    # The create2 account is shared by both L2s, so don't redeploy it if we are deploying onto an
-    # existing L1.
-    if not deploy_l2:
+    # The create2 account is shared by both L2s, so don't redeploy it unless necessary
+    # We check to see if the create2 deployer exists by querying its balance
+    res = run_command(
+        ["cast", "balance", "0x3fAB184622Dc19b6109349B94811493BF2a45362"],
+        capture_output=True,
+    )
+    deployer_balance = int(res.stdout.strip())
+    if deployer_balance == 0:
         # send some ether to the create2 deployer account
         run_command([
             'cast', 'send', '--from', account,
@@ -205,6 +211,7 @@ def devnet_deploy(paths, args):
     espresso = args.espresso
     l2 = args.l2
     l2_provider_url = args.l2_provider_url
+    compose_file = args.compose_file
 
     if os.path.exists(paths.genesis_l1_path) and os.path.isfile(paths.genesis_l1_path):
         log.info('L1 genesis already generated.')
@@ -237,7 +244,7 @@ def devnet_deploy(paths, args):
     else:
         # Deploy L1 and sequencer network.
         log.info('Starting L1.')
-        run_command(['docker', 'compose', 'up', '-d', 'l1'], cwd=paths.ops_bedrock_dir, env={
+        run_command(['docker', 'compose', '-f', compose_file, 'up', '-d', 'l1'], cwd=paths.ops_bedrock_dir, env={
             'PWD': paths.ops_bedrock_dir,
             'DEVNET_DIR': paths.devnet_dir
         })
@@ -254,7 +261,7 @@ def devnet_deploy(paths, args):
                 'sequencer0',
                 'sequencer1',
             ]
-            run_command(['docker-compose', 'up', '-d'] + espresso_services, cwd=paths.ops_bedrock_dir, env={
+            run_command(['docker-compose', '-f', compose_file, 'up', '-d'] + espresso_services, cwd=paths.ops_bedrock_dir, env={
                 'PWD': paths.ops_bedrock_dir,
                 'DEVNET_DIR': paths.devnet_dir
             })
@@ -277,7 +284,7 @@ def devnet_deploy(paths, args):
     addresses = read_json(paths.addresses_json_path)
 
     log.info('Bringing up L2.')
-    run_command(['docker', 'compose', 'up', '-d', f'{l2}-l2', f'{l2}-geth-proxy'], cwd=paths.ops_bedrock_dir, env={
+    run_command(['docker', 'compose', '-f', compose_file, 'up', '-d', f'{l2}-l2', f'{l2}-geth-proxy'], cwd=paths.ops_bedrock_dir, env={
         'PWD': paths.ops_bedrock_dir,
         'DEVNET_DIR': paths.devnet_dir
     })
@@ -293,7 +300,7 @@ def devnet_deploy(paths, args):
     log.info(f'Using batch inbox {batch_inbox_address}')
 
     log.info('Bringing up everything else.')
-    command = ['docker', 'compose', 'up', '-d']
+    command = ['docker', 'compose', '-f', compose_file, 'up', '-d']
     if args.deploy_l2:
         # If we are deploying onto an existing L1, don't restart the services that are already
         # running.
@@ -307,7 +314,7 @@ def devnet_deploy(paths, args):
     })
 
     log.info('Starting block explorer')
-    run_command(['docker-compose', 'up', '-d', f'{l2}-blockscout'], cwd=paths.ops_bedrock_dir)
+    run_command(['docker-compose', '-f', compose_file, 'up', '-d', f'{l2}-blockscout'], cwd=paths.ops_bedrock_dir)
 
     log.info('Devnet ready.')
 
@@ -388,12 +395,13 @@ def devnet_test(paths, l2_provider_url, faucet_url):
          timeout=8*60,
     )
 
-def run_command(args, check=True, shell=False, cwd=None, env=None, timeout=None):
+def run_command(args, check=True, shell=False, cwd=None, env=None, timeout=None, capture_output=False):
     env = env if env else {}
     return subprocess.run(
         args,
         check=check,
         shell=shell,
+        capture_output=capture_output,
         env={
             **os.environ,
             **env

op-node/rollup/derive/batches.go

@@ -37,16 +37,23 @@ const (
 // conform with the constraints of the derivation pipeline. The resulting L1 origin will always be
 // the same as parent's or one block after parent's, will always conform to the derivation
 // constraints, and is deterministic given `parent` and `suggested.`
-func EspressoL1Origin(cfg *rollup.Config, parent eth.L2BlockRef, suggested eth.L1BlockRef) uint64 {
+func EspressoL1Origin(cfg *rollup.Config, parent eth.L2BlockRef, suggested eth.L1BlockRef, nextL1Block eth.L1BlockRef, l log.Logger) uint64 {
 	prev := parent.L1Origin
 	windowStart := parent.Time + cfg.BlockTime
+	nextL1BlockEligible := nextL1Block.Time <= windowStart
 
 	// Constraint 1: the L1 origin must not skip an L1 block.
 	if suggested.Number > prev.Number+1 {
 		// If we did skip an L1 block, that is Espresso telling us that multiple new L1 blocks have
 		// already been produced. In this case, we will not block when fetching the next L1 origin,
 		// so advance as far as the derivation pipeline allows: one block.
-		return prev.Number + 1
+		if nextL1BlockEligible {
+			l.Info("We skipped an L1 block and the next L1 block is eligible as an origin, advancing by one")
+			return prev.Number + 1
+		} else {
+			l.Info("We skipped an L1 block and the next L1 block is not eligible as an origin, using the old origin")
+			return prev.Number
+		}
 	}
 	// Constraint 2: the L1 origin number decreased.
 	//
@@ -57,6 +64,7 @@ func EspressoL1Origin(cfg *rollup.Config, parent eth.L2BlockRef, suggested eth.L
 		// In this case, we have no indication that new L1 blocks are ready. We don't want to
 		// advance the L1 origin number and force the derivation pipeline to block waiting for a new
 		// L1 block to be produced, so just reuse the previous L1 origin.
+		l.Info("L1 origin decreased, using the old origin")
 		return prev.Number
 	}
 	// Constraint 3: the L1 origin is too old.
@@ -65,6 +73,7 @@ func EspressoL1Origin(cfg *rollup.Config, parent eth.L2BlockRef, suggested eth.L
 		// forced to advance the L1 origin. At worst, the derivation pipeline may block until the
 		// next L1 origin is available, but if the chosen L1 origin is this old, it is likely that a
 		// new L1 block is available and Espresso just hasn't seen it yet for some reason.
+		l.Info("L1 origin is too old, advancing by one")
 		return prev.Number + 1
 	}
 	// Constraint 4: the L1 origin must not be newer than the L2 batch.
@@ -73,6 +82,7 @@ func EspressoL1Origin(cfg *rollup.Config, parent eth.L2BlockRef, suggested eth.L
 		// timestamp earlier than `prev`, and thus earlier than the current batch. Espresso must be
 		// running ahead of the L2, which is fine, we'll just wait to advance the L1 origin until
 		// the L2 chain catches up.
+		l.Info("L1 origin is newer than the L2 batch, use the previous origin")
 		return prev.Number
 	}
 
@@ -139,7 +149,13 @@ func CheckBatchEspresso(cfg *rollup.Config, log log.Logger, l2SafeHead eth.L2Blo
 		log.Warn("error reading suggested L1 origin", "err", err, "l1 head", jst.Next.L1Head)
 		return BatchUndecided
 	}
-	expectedL1Origin := EspressoL1Origin(cfg, l2SafeHead, suggestedL1Origin)
+	nextL1Number := l2SafeHead.L1Origin.Number + 1
+	nextL1Block, err := l1.L1BlockRefByNumber(context.Background(), nextL1Number)
+	if err != nil {
+		log.Warn("error reading next possible L1 origin", "err", err, "origin", nextL1Number)
+		return BatchUndecided
+	}
+	expectedL1Origin := EspressoL1Origin(cfg, l2SafeHead, suggestedL1Origin, nextL1Block, log)
 	actualL1Origin := uint64(batch.Batch.EpochNum)
 	if expectedL1Origin != actualL1Origin {
 		log.Warn("dropping batch because L1 origin was not set correctly",

op-node/rollup/driver/sequencer.go

@@ -198,7 +198,12 @@ func (d *Sequencer) sealEspressoBatch(ctx context.Context) (*eth.ExecutionPayloa
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch suggested L1 origin %d: %w", batch.jst.Next.L1Head, err)
 	}
-	l1OriginNumber := derive.EspressoL1Origin(d.config, batch.onto, suggestedL1Origin)
+	nextL1Number := batch.onto.L1Origin.Number + 1
+	nextL1Block, err := d.l1OriginSelector.FindL1OriginByNumber(ctx, nextL1Number)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch next possible L1 origin %d: %w", nextL1Block, err)
+	}
+	l1OriginNumber := derive.EspressoL1Origin(d.config, batch.onto, suggestedL1Origin, nextL1Block, d.log)
 	l1Origin := suggestedL1Origin
 	if l1Origin.Number != l1OriginNumber {
 		l1Origin, err = d.l1OriginSelector.FindL1OriginByNumber(ctx, l1OriginNumber)