Support BOLD Challenges on Ethereum Sepolia

.gitmodules

@@ -20,3 +20,6 @@
 [submodule "nitro-testnode"]
 	path = nitro-testnode
 	url = https://github.com/OffchainLabs/nitro-testnode.git
+[submodule "bold"]
+	path = bold
+	url = https://github.com/OffchainLabs/bold.git

Dockerfile

@@ -75,6 +75,7 @@ COPY ./contracts/package.json ./contracts/yarn.lock ./contracts/
 COPY ./solgen/gen.go ./solgen/
 COPY ./fastcache ./fastcache
 COPY ./go-ethereum ./go-ethereum
+COPY ./bold ./bold
 COPY --from=brotli-wasm-export / target/
 COPY --from=contracts-builder workspace/contracts/build/contracts/src/precompiles/ contracts/build/contracts/src/precompiles/
 COPY --from=contracts-builder workspace/contracts/node_modules/@offchainlabs/upgrade-executor/build/contracts/src/UpgradeExecutor.sol/UpgradeExecutor.json contracts/
@@ -179,6 +180,7 @@ RUN export DEBIAN_FRONTEND=noninteractive && \
 COPY go.mod go.sum ./
 COPY go-ethereum/go.mod go-ethereum/go.sum go-ethereum/
 COPY fastcache/go.mod fastcache/go.sum fastcache/
+COPY bold/go.mod bold/go.sum bold/
 RUN go mod download
 COPY . ./
 COPY --from=contracts-builder workspace/contracts/build/ contracts/build/
@@ -251,6 +253,7 @@ USER root
 RUN rm -f /home/user/target/machines/latest
 COPY --from=prover-export /bin/jit                                         /usr/local/bin/
 COPY --from=node-builder  /workspace/target/bin/deploy                     /usr/local/bin/
+COPY --from=node-builder  /workspace/target/bin/bold-deploy                /usr/local/bin/
 COPY --from=node-builder  /workspace/target/bin/seq-coordinator-invalidate /usr/local/bin/
 COPY --from=module-root-calc /workspace/target/machines/latest/machine.wavm.br /home/user/target/machines/latest/
 COPY --from=module-root-calc /workspace/target/machines/latest/until-host-io-state.bin /home/user/target/machines/latest/

Makefile

@@ -88,7 +88,7 @@ push: lint test-go .make/fmt
 all: build build-replay-env test-gen-proofs
 	@touch .make/all
 
-build: $(patsubst %,$(output_root)/bin/%, nitro deploy relay daserver datool seq-coordinator-invalidate nitro-val seq-coordinator-manager)
+build: $(patsubst %,$(output_root)/bin/%, nitro deploy bold-deploy relay daserver datool seq-coordinator-invalidate nitro-val seq-coordinator-manager)
 	@printf $(done)
 
 build-node-deps: $(go_source) build-prover-header build-prover-lib build-jit .make/solgen .make/cbrotli-lib
@@ -170,6 +170,9 @@ $(output_root)/bin/nitro: $(DEP_PREDICATE) build-node-deps
 $(output_root)/bin/deploy: $(DEP_PREDICATE) build-node-deps
 	go build $(GOLANG_PARAMS) -o $@ "$(CURDIR)/cmd/deploy"
 
+$(output_root)/bin/bold-deploy: $(DEP_PREDICATE) build-node-deps
+	go build $(GOLANG_PARAMS) -o $@ "$(CURDIR)/cmd/bold-deploy"
+
 $(output_root)/bin/relay: $(DEP_PREDICATE) build-node-deps
 	go build $(GOLANG_PARAMS) -o $@ "$(CURDIR)/cmd/relay"
 

arbitrator/prover/src/lib.rs

@@ -89,10 +89,17 @@ unsafe fn arbitrator_load_machine_impl(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn arbitrator_load_wavm_binary(binary_path: *const c_char) -> *mut Machine {
+pub unsafe extern "C" fn arbitrator_load_wavm_binary(
+    binary_path: *const c_char,
+    always_merkleize: u8,
+) -> *mut Machine {
     let binary_path = cstr_to_string(binary_path);
     let binary_path = Path::new(&binary_path);
-    match Machine::new_from_wavm(binary_path) {
+    let mut merkleize = false;
+    if always_merkleize == 1 {
+        merkleize = true;
+    }
+    match Machine::new_from_wavm(binary_path, merkleize) {
         Ok(mach) => Box::into_raw(Box::new(mach)),
         Err(err) => {
             eprintln!("Error loading binary: {}", err);

arbitrator/prover/src/machine.rs

@@ -1165,7 +1165,7 @@ impl Machine {
         Ok(mach)
     }
 
-    pub fn new_from_wavm(wavm_binary: &Path) -> Result<Machine> {
+    pub fn new_from_wavm(wavm_binary: &Path, always_merkleize: bool) -> Result<Machine> {
         let f = BufReader::new(File::open(wavm_binary)?);
         let decompressor = brotli2::read::BrotliDecoder::new(f);
         let mut modules: Vec<Module> = bincode::deserialize_from(decompressor)?;
@@ -1191,6 +1191,16 @@ impl Machine {
                 MerkleType::Function,
                 module.funcs.iter().map(Function::hash).collect(),
             ));
+            if always_merkleize {
+                module.memory.cache_merkle_tree();
+            }
+        }
+        let mut modules_merkle = None;
+        if always_merkleize {
+            modules_merkle = Some(Merkle::new(
+                MerkleType::Module,
+                modules.iter().map(Module::hash).collect(),
+            ));
         }
         let mut mach = Machine {
             status: MachineStatus::Running,
@@ -1199,7 +1209,7 @@ impl Machine {
             internal_stack: Vec::new(),
             frame_stack: Vec::new(),
             modules,
-            modules_merkle: None,
+            modules_merkle,
             global_state: Default::default(),
             pc: ProgramCounter::default(),
             stdio_output: Vec::new(),

arbnode/dataposter/data_poster.go

@@ -256,10 +256,11 @@ func (p *DataPoster) Sender() common.Address {
 }
 
 func (p *DataPoster) MaxMempoolTransactions() uint64 {
-	if p.usingNoOpStorage {
-		return 1
-	}
-	return p.config().MaxMempoolTransactions
+	// if p.usingNoOpStorage {
+	// 	return 1
+	// }
+	// return p.config().MaxMempoolTransactions
+	return 1000
 }
 
 // Does basic check whether posting transaction with specified nonce would
@@ -491,6 +492,18 @@ func (p *DataPoster) PostTransaction(ctx context.Context, dataCreatedAt time.Tim
 	return fullTx, p.sendTx(ctx, nil, &queuedTx)
 }
 
+func (p *DataPoster) PostSimpleTransactionAutoNonce(ctx context.Context, to common.Address, calldata []byte, gasLimit uint64, value *big.Int) (*types.Transaction, error) {
+	nonce, _, err := p.GetNextNonceAndMeta(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return p.PostSimpleTransaction(ctx, nonce, to, calldata, gasLimit, value)
+}
+
+func (p *DataPoster) PostSimpleTransaction(ctx context.Context, nonce uint64, to common.Address, calldata []byte, gasLimit uint64, value *big.Int) (*types.Transaction, error) {
+	return p.PostTransaction(ctx, time.Now(), nonce, nil, to, calldata, gasLimit, value, nil)
+}
+
 // the mutex must be held by the caller
 func (p *DataPoster) saveTx(ctx context.Context, prevTx, newTx *storage.QueuedTransaction) error {
 	if prevTx != nil && prevTx.Data.Nonce != newTx.Data.Nonce {
@@ -826,7 +839,7 @@ var DefaultDataPosterConfig = DataPosterConfig{
 	WaitForL1Finality:      true,
 	TargetPriceGwei:        60.,
 	UrgencyGwei:            2.,
-	MaxMempoolTransactions: 10,
+	MaxMempoolTransactions: 1000,
 	MinTipCapGwei:          0.05,
 	MaxTipCapGwei:          5,
 	NonceRbfSoftConfs:      1,
@@ -840,7 +853,7 @@ var DefaultDataPosterConfig = DataPosterConfig{
 
 var DefaultDataPosterConfigForValidator = func() DataPosterConfig {
 	config := DefaultDataPosterConfig
-	config.MaxMempoolTransactions = 1 // the validator cannot queue transactions
+	config.MaxMempoolTransactions = 1000
 	return config
 }()
 
@@ -850,7 +863,7 @@ var TestDataPosterConfig = DataPosterConfig{
 	WaitForL1Finality:      false,
 	TargetPriceGwei:        60.,
 	UrgencyGwei:            2.,
-	MaxMempoolTransactions: 10,
+	MaxMempoolTransactions: 1000,
 	MinTipCapGwei:          0.05,
 	MaxTipCapGwei:          5,
 	NonceRbfSoftConfs:      1,

arbnode/node.go

@@ -12,8 +12,12 @@ import (
 	"strings"
 	"time"
 
+	solimpl "github.com/OffchainLabs/bold/chain-abstraction/sol-implementation"
+	challengemanager "github.com/OffchainLabs/bold/challenge-manager"
 	flag "github.com/spf13/pflag"
 
+	modes "github.com/OffchainLabs/bold/challenge-manager/types"
+	l2stateprovider "github.com/OffchainLabs/bold/layer2-state-provider"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
@@ -91,6 +95,7 @@ type Config struct {
 	TransactionStreamer TransactionStreamerConfig   `koanf:"transaction-streamer" reload:"hot"`
 	Maintenance         MaintenanceConfig           `koanf:"maintenance" reload:"hot"`
 	ResourceMgmt        resourcemanager.Config      `koanf:"resource-mgmt" reload:"hot"`
+	Bold                staker.BoldConfig           `koanf:"bold" reload:"hot"`
 }
 
 func (c *Config) Validate() error {
@@ -118,6 +123,9 @@ func (c *Config) Validate() error {
 	if err := c.Staker.Validate(); err != nil {
 		return err
 	}
+	if err := c.Bold.Validate(); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -158,6 +166,7 @@ var ConfigDefault = Config{
 	MessagePruner:       DefaultMessagePrunerConfig,
 	BlockValidator:      staker.DefaultBlockValidatorConfig,
 	Feed:                broadcastclient.FeedConfigDefault,
+	Bold:                staker.DefaultBoldConfig,
 	Staker:              staker.DefaultL1ValidatorConfig,
 	SeqCoordinator:      DefaultSeqCoordinatorConfig,
 	DataAvailability:    das.DefaultDataAvailabilityConfig,
@@ -546,6 +555,89 @@ func createNodeImpl(
 		statelessBlockValidator = nil
 	}
 
+	if config.Bold.Enable {
+		dp, err := StakerDataposter(
+			ctx,
+			rawdb.NewTable(arbDb, storage.StakerPrefix),
+			l1Reader,
+			txOptsValidator,
+			configFetcher,
+			syncMonitor,
+		)
+		if err != nil {
+			return nil, err
+		}
+		rollupBindings, err := rollupgen.NewRollupUserLogic(deployInfo.Rollup, l1client)
+		if err != nil {
+			return nil, fmt.Errorf("could not create rollup bindings: %w", err)
+		}
+		chalManager, err := rollupBindings.ChallengeManager(&bind.CallOpts{})
+		if err != nil {
+			return nil, fmt.Errorf("could not get challenge manager: %w", err)
+		}
+		assertionChain, err := solimpl.NewAssertionChain(ctx, deployInfo.Rollup, chalManager, txOptsValidator, l1client, solimpl.NewDataPosterTransactor(dp))
+		if err != nil {
+			return nil, fmt.Errorf("could not create assertion chain: %w", err)
+		}
+		blockChallengeLeafHeight := l2stateprovider.Height(config.Bold.BlockChallengeLeafHeight)
+		bigStepHeight := l2stateprovider.Height(config.Bold.BigStepLeafHeight)
+		smallStepHeight := l2stateprovider.Height(config.Bold.SmallStepLeafHeight)
+		stateManager, err := staker.NewStateManager(
+			statelessBlockValidator,
+			config.Bold.MachineLeavesCachePath,
+			[]l2stateprovider.Height{
+				blockChallengeLeafHeight,
+				bigStepHeight,
+				smallStepHeight,
+			},
+			config.Bold.ValidatorName,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("could not create state manager: %w", err)
+		}
+		providerHeights := []l2stateprovider.Height{blockChallengeLeafHeight}
+		for i := uint64(0); i < config.Bold.NumBigSteps; i++ {
+			providerHeights = append(providerHeights, bigStepHeight)
+		}
+		providerHeights = append(providerHeights, smallStepHeight)
+		provider := l2stateprovider.NewHistoryCommitmentProvider(
+			stateManager,
+			stateManager,
+			stateManager,
+			providerHeights,
+			stateManager,
+			nil,
+		)
+		postingInterval := time.Second * time.Duration(config.Bold.AssertionPostingIntervalSeconds)
+		scanningInteval := time.Second * time.Duration(config.Bold.AssertionScanningIntervalSeconds)
+		confirmingInterval := time.Second * time.Duration(config.Bold.AssertionConfirmingIntervalSeconds)
+		edgeWakeInterval := time.Second * time.Duration(config.Bold.EdgeTrackerWakeIntervalSeconds)
+		opts := []challengemanager.Opt{
+			challengemanager.WithName(config.Bold.ValidatorName),
+			challengemanager.WithMode(modes.MakeMode), // TODO: Customize.
+			challengemanager.WithAssertionPostingInterval(postingInterval),
+			challengemanager.WithAssertionScanningInterval(scanningInteval),
+			challengemanager.WithAssertionConfirmingInterval(confirmingInterval),
+			challengemanager.WithEdgeTrackerWakeInterval(edgeWakeInterval),
+			challengemanager.WithAddress(txOptsValidator.From),
+		}
+		if config.Bold.API {
+			opts = append(opts, challengemanager.WithAPIEnabled(fmt.Sprintf("%s:%d", config.Bold.APIHost, config.Bold.APIPort), config.Bold.APIDBPath))
+		}
+		manager, err := challengemanager.New(
+			ctx,
+			assertionChain,
+			provider,
+			assertionChain.RollupAddress(),
+			opts...,
+		)
+		if err != nil {
+			return nil, fmt.Errorf("could not create challenge manager: %w", err)
+		}
+		provider.UpdateAPIDatabase(manager.Database())
+		go manager.Start(ctx)
+	}
+
 	var blockValidator *staker.BlockValidator
 	if config.ValidatorRequired() {
 		blockValidator, err = staker.NewBlockValidator(
@@ -611,7 +703,7 @@ func createNodeImpl(
 			confirmedNotifiers = append(confirmedNotifiers, messagePruner)
 		}
 
-		stakerObj, err = staker.NewStaker(l1Reader, wallet, bind.CallOpts{}, config.Staker, blockValidator, statelessBlockValidator, nil, confirmedNotifiers, deployInfo.ValidatorUtils, fatalErrChan)
+		stakerObj, err = staker.NewStaker(l1Reader, wallet, bind.CallOpts{}, config.Staker, blockValidator, statelessBlockValidator, nil, confirmedNotifiers, deployInfo.ValidatorUtils, deployInfo.Bridge, fatalErrChan)
 		if err != nil {
 			return nil, err
 		}

arbos/block_processor.go

@@ -125,6 +125,27 @@ func NoopSequencingHooks() *SequencingHooks {
 	}
 }
 
+type ProduceConfig struct {
+	evil                       bool
+	interceptDepositGweiAmount *big.Int
+}
+type ProduceOpt func(*ProduceConfig)
+
+func WithEvilProduction() ProduceOpt {
+	return func(pc *ProduceConfig) {
+		pc.evil = true
+	}
+}
+
+func WithInterceptDepositSize(depositGwei *big.Int) ProduceOpt {
+	return func(pc *ProduceConfig) {
+		pc.interceptDepositGweiAmount = depositGwei
+	}
+}
+
+// By default, intercept and modify any Arbitrum deposits with a value of a 1M gwei, or 0.001 ETH.
+var DefaultEvilInterceptDepositGweiAmount = big.NewInt(1_000_000 * params.GWei) // 0.001 ETH
+
 func ProduceBlock(
 	message *arbostypes.L1IncomingMessage,
 	delayedMessagesRead uint64,
@@ -133,6 +154,7 @@ func ProduceBlock(
 	chainContext core.ChainContext,
 	chainConfig *params.ChainConfig,
 	batchFetcher arbostypes.FallibleBatchFetcher,
+	opts ...ProduceOpt,
 ) (*types.Block, types.Receipts, error) {
 	var batchFetchErr error
 	txes, err := ParseL2Transactions(message, chainConfig.ChainID, func(batchNum uint64, batchHash common.Hash) []byte {
@@ -156,9 +178,40 @@ func ProduceBlock(
 		txes = types.Transactions{}
 	}
 
+	produceCfg := &ProduceConfig{
+		interceptDepositGweiAmount: DefaultEvilInterceptDepositGweiAmount,
+	}
+	for _, o := range opts {
+		o(produceCfg)
+	}
+
+	var modifiedTxs []*types.Transaction
+	if produceCfg.evil {
+		modifiedTxs = make([]*types.Transaction, 0, len(txes))
+		for _, tx := range txes {
+			txData, ok := tx.GetInner().(*types.ArbitrumDepositTx)
+			if !ok {
+				// We only intercept Arbitrum deposit txs at the moment.
+				modifiedTxs = append(modifiedTxs, tx)
+				continue
+			}
+			if txData.Value.Cmp(produceCfg.interceptDepositGweiAmount) != 0 {
+				modifiedTxs = append(modifiedTxs, tx)
+				continue
+			}
+			newValue := new(big.Int).Add(txData.Value, big.NewInt(params.GWei))
+			log.Info(fmt.Sprintf("Modified tx value in evil validator with value %d, to value %d as hex %#x and %#x", txData.Value.Uint64(), newValue.Uint64(), txData.Value.Bytes(), newValue.Bytes()))
+			txData.Value = newValue
+			modified := types.NewTx(txData)
+			modifiedTxs = append(modifiedTxs, modified)
+		}
+	} else {
+		modifiedTxs = txes
+	}
+
 	hooks := NoopSequencingHooks()
 	return ProduceBlockAdvanced(
-		message.Header, txes, delayedMessagesRead, lastBlockHeader, statedb, chainContext, chainConfig, hooks,
+		message.Header, modifiedTxs, delayedMessagesRead, lastBlockHeader, statedb, chainContext, chainConfig, hooks,
 	)
 }