Support the Arbitrum BoLD Challenge Protocol in Nitro

cmd/chaininfo/arbitrum_chain_info.json

@@ -44,7 +44,7 @@
       "sequencer-inbox": "0x1c479675ad559dc151f6ec7ed3fbf8cee79582b6",
       "validator-utils": "0x9e40625f52829cf04bc4839f186d621ee33b0e67",
       "validator-wallet-creator": "0x960953f7c69cd2bc2322db9223a815c680ccc7ea",
-      "stake-token": "0x0000000000000000000000000000000000000000",
+      "stake-token": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
       "deployed-at": 15411056
     }
   },
@@ -91,7 +91,7 @@
       "sequencer-inbox": "0x211e1c4c7f1bf5351ac850ed10fd68cffcf6c21b",
       "validator-utils": "0x2B081fbaB646D9013f2699BebEf62B7e7d7F0976",
       "validator-wallet-creator": "0xe05465Aab36ba1277dAE36aa27a7B74830e74DE4",
-      "stake-token": "0x0000000000000000000000000000000000000000",
+      "stake-token": "0x765277eebeca2e31912c9946eae1021199b39c61",
       "deployed-at": 15016829
     }
   },

cmd/nitro/nitro.go

@@ -290,7 +290,7 @@ func mainImpl() int {
 			flag.Usage()
 			log.Crit("validator must have the parent chain reader enabled")
 		}
-		strategy, err := nodeConfig.Node.Staker.ParseStrategy()
+		strategy, err := legacystaker.ParseStrategy(nodeConfig.Node.Staker.Strategy)
 		if err != nil {
 			log.Crit("couldn't parse staker strategy", "err", err)
 		}

staker/bold/bold_staker.go

@@ -7,6 +7,8 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"os"
+	"path/filepath"
 	"time"
 
 	flag "github.com/spf13/pflag"
@@ -22,10 +24,12 @@ import (
 	challengemanager "github.com/offchainlabs/bold/challenge-manager"
 	boldtypes "github.com/offchainlabs/bold/challenge-manager/types"
 	l2stateprovider "github.com/offchainlabs/bold/layer2-state-provider"
+	"github.com/offchainlabs/bold/solgen/go/challengeV2gen"
 	boldrollup "github.com/offchainlabs/bold/solgen/go/rollupgen"
 	"github.com/offchainlabs/bold/util"
 	"github.com/offchainlabs/nitro/arbnode/dataposter"
 	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/offchainlabs/nitro/cmd/conf"
 	"github.com/offchainlabs/nitro/staker"
 	legacystaker "github.com/offchainlabs/nitro/staker/legacy"
 	"github.com/offchainlabs/nitro/util/headerreader"
@@ -34,6 +38,7 @@ import (
 )
 
 var assertionCreatedId common.Hash
+var homeDir string
 
 func init() {
 	rollupAbi, err := boldrollup.RollupCoreMetaData.GetAbi()
@@ -45,17 +50,16 @@ func init() {
 		panic("RollupCore ABI missing AssertionCreated event")
 	}
 	assertionCreatedId = assertionCreatedEvent.ID
+	homeDirPath, err := os.UserHomeDir()
+	if err != nil {
+		panic(err)
+	}
+	homeDir = homeDirPath
 }
 
 type BoldConfig struct {
-	Enable bool   `koanf:"enable"`
-	Mode   string `koanf:"mode"`
-	// The height constants at each challenge level for the BOLD challenge manager.
-	BlockChallengeLeafHeight uint64 `koanf:"block-challenge-leaf-height"`
-	BigStepLeafHeight        uint64 `koanf:"big-step-leaf-height"`
-	SmallStepLeafHeight      uint64 `koanf:"small-step-leaf-height"`
-	// Number of big step challenges in the BOLD protocol.
-	NumBigSteps uint64 `koanf:"num-big-steps"`
+	Enable   bool   `koanf:"enable"`
+	Strategy string `koanf:"strategy"`
 	// How often to post assertions onchain.
 	AssertionPostingInterval time.Duration `koanf:"assertion-posting-interval"`
 	// How often to scan for newly created assertions onchain.
@@ -70,6 +74,16 @@ type BoldConfig struct {
 	CheckStakerSwitchInterval           time.Duration       `koanf:"check-staker-switch-interval"`
 	StateProviderConfig                 StateProviderConfig `koanf:"state-provider-config"`
 	StartValidationFromStaked           bool                `koanf:"start-validation-from-staked"`
+	strategy                            legacystaker.StakerStrategy
+}
+
+func (c *BoldConfig) Validate() error {
+	strategy, err := legacystaker.ParseStrategy(c.Strategy)
+	if err != nil {
+		return err
+	}
+	c.strategy = strategy
+	return nil
 }
 
 type StateProviderConfig struct {
@@ -83,43 +97,35 @@ type StateProviderConfig struct {
 var DefaultStateProviderConfig = StateProviderConfig{
 	ValidatorName:          "default-validator",
 	CheckBatchFinality:     true,
-	MachineLeavesCachePath: "/tmp/machine-leaves-cache",
+	MachineLeavesCachePath: filepath.Join(homeDir, conf.PersistentConfigDefault.GlobalConfig, "machine-hashes-cache"),
 }
 
 var DefaultBoldConfig = BoldConfig{
 	Enable:                              false,
-	Mode:                                "make-mode",
-	BlockChallengeLeafHeight:            1 << 26,
-	BigStepLeafHeight:                   1 << 23,
-	SmallStepLeafHeight:                 1 << 19,
-	NumBigSteps:                         1,
+	Strategy:                            "Watchtower",
 	AssertionPostingInterval:            time.Minute * 15,
 	AssertionScanningInterval:           time.Minute,
 	AssertionConfirmingInterval:         time.Minute,
 	API:                                 false,
 	APIHost:                             "127.0.0.1",
 	APIPort:                             9393,
-	APIDBPath:                           "/tmp/bold-api-db",
+	APIDBPath:                           filepath.Join(homeDir, conf.PersistentConfigDefault.GlobalConfig, "bold-api-db"),
 	TrackChallengeParentAssertionHashes: []string{},
 	CheckStakerSwitchInterval:           time.Minute, // Every minute, check if the Nitro node staker should switch to using BOLD.
 	StateProviderConfig:                 DefaultStateProviderConfig,
 	StartValidationFromStaked:           true,
 }
 
-var BoldModes = map[string]boldtypes.Mode{
-	"watchtower-mode": boldtypes.WatchTowerMode,
-	"resolve-mode":    boldtypes.ResolveMode,
-	"defensive-mode":  boldtypes.DefensiveMode,
-	"make-mode":       boldtypes.MakeMode,
+var BoldModes = map[legacystaker.StakerStrategy]boldtypes.Mode{
+	legacystaker.WatchtowerStrategy:   boldtypes.WatchTowerMode,
+	legacystaker.DefensiveStrategy:    boldtypes.DefensiveMode,
+	legacystaker.ResolveNodesStrategy: boldtypes.ResolveMode,
+	legacystaker.MakeNodesStrategy:    boldtypes.MakeMode,
 }
 
 func BoldConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Bool(prefix+".enable", DefaultBoldConfig.Enable, "enable bold challenge protocol")
-	f.String(prefix+".mode", DefaultBoldConfig.Mode, "define the bold validator staker strategy")
-	f.Uint64(prefix+".block-challenge-leaf-height", DefaultBoldConfig.BlockChallengeLeafHeight, "block challenge leaf height")
-	f.Uint64(prefix+".big-step-leaf-height", DefaultBoldConfig.BigStepLeafHeight, "big challenge leaf height")
-	f.Uint64(prefix+".small-step-leaf-height", DefaultBoldConfig.SmallStepLeafHeight, "small challenge leaf height")
-	f.Uint64(prefix+".num-big-steps", DefaultBoldConfig.NumBigSteps, "num big steps")
+	f.String(prefix+".strategy", DefaultBoldConfig.Strategy, "define the bold validator staker strategy, either watchtower, defensive, stakeLatest, or makeNodes")
 	f.Duration(prefix+".assertion-posting-interval", DefaultBoldConfig.AssertionPostingInterval, "assertion posting interval")
 	f.Duration(prefix+".assertion-scanning-interval", DefaultBoldConfig.AssertionScanningInterval, "scan assertion interval")
 	f.Duration(prefix+".assertion-confirming-interval", DefaultBoldConfig.AssertionConfirmingInterval, "confirm assertion interval")
@@ -147,7 +153,6 @@ type BOLDStaker struct {
 	statelessBlockValidator *staker.StatelessBlockValidator
 	rollupAddress           common.Address
 	l1Reader                *headerreader.HeaderReader
-	lastWasmModuleRoot      common.Hash
 	client                  protocol.ChainBackend
 	callOpts                bind.CallOpts
 	wallet                  legacystaker.ValidatorWalletInterface
@@ -169,6 +174,9 @@ func NewBOLDStaker(
 	stakedNotifiers []legacystaker.LatestStakedNotifier,
 	confirmedNotifiers []legacystaker.LatestConfirmedNotifier,
 ) (*BOLDStaker, error) {
+	if err := config.Validate(); err != nil {
+		return nil, err
+	}
 	wrappedClient := util.NewBackendWrapper(l1Reader.Client(), rpc.LatestBlockNumber)
 	manager, err := newBOLDChallengeManager(ctx, rollupAddress, txOpts, l1Reader, wrappedClient, blockValidator, statelessBlockValidator, config, dataPoster)
 	if err != nil {
@@ -192,15 +200,16 @@ func NewBOLDStaker(
 // Initialize Updates the block validator module root.
 // And updates the init state of the block validator if block validator has not started yet.
 func (b *BOLDStaker) Initialize(ctx context.Context) error {
-	if err := b.updateBlockValidatorModuleRoot(ctx); err != nil {
-		return err
+	err := b.updateBlockValidatorModuleRoot(ctx)
+	if err != nil {
+		log.Warn("error updating latest wasm module root", "err", err)
 	}
 	walletAddressOrZero := b.wallet.AddressOrZero()
 	var stakerAddr common.Address
 	if b.wallet.DataPoster() != nil {
 		stakerAddr = b.wallet.DataPoster().Sender()
 	}
-	log.Info("running as validator", "txSender", stakerAddr, "actingAsWallet", walletAddressOrZero, "mode", b.config.Mode)
+	log.Info("running as validator", "txSender", stakerAddr, "actingAsWallet", walletAddressOrZero, "strategy", b.config.Strategy)
 
 	if b.blockValidator != nil && b.config.StartValidationFromStaked && !b.blockValidator.Started() {
 		rollupUserLogic, err := boldrollup.NewRollupUserLogic(b.rollupAddress, b.client)
@@ -326,16 +335,7 @@ func (b *BOLDStaker) updateBlockValidatorModuleRoot(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	if moduleRoot != b.lastWasmModuleRoot {
-		err := b.blockValidator.SetCurrentWasmModuleRoot(moduleRoot)
-		if err != nil {
-			return err
-		}
-		b.lastWasmModuleRoot = moduleRoot
-	} else if (moduleRoot == common.Hash{}) {
-		return errors.New("wasmModuleRoot in rollup is zero")
-	}
-	return nil
+	return b.blockValidator.SetCurrentWasmModuleRoot(moduleRoot)
 }
 
 func (b *BOLDStaker) getCallOpts(ctx context.Context) *bind.CallOpts {
@@ -367,13 +367,43 @@ func newBOLDChallengeManager(
 	if err != nil {
 		return nil, fmt.Errorf("could not get challenge manager: %w", err)
 	}
+	chalManagerBindings, err := challengeV2gen.NewEdgeChallengeManager(chalManager, client)
+	if err != nil {
+		return nil, fmt.Errorf("could not create challenge manager bindings: %w", err)
+	}
 	assertionChain, err := solimpl.NewAssertionChain(ctx, rollupAddress, chalManager, txOpts, client, NewDataPosterTransactor(dataPoster))
 	if err != nil {
 		return nil, fmt.Errorf("could not create assertion chain: %w", err)
 	}
-	blockChallengeLeafHeight := l2stateprovider.Height(config.BlockChallengeLeafHeight)
-	bigStepHeight := l2stateprovider.Height(config.BigStepLeafHeight)
-	smallStepHeight := l2stateprovider.Height(config.SmallStepLeafHeight)
+
+	blockChallengeHeightBig, err := chalManagerBindings.LAYERZEROBLOCKEDGEHEIGHT(&bind.CallOpts{})
+	if err != nil {
+		return nil, fmt.Errorf("could not get block challenge height: %w", err)
+	}
+	if !blockChallengeHeightBig.IsUint64() {
+		return nil, errors.New("block challenge height was not a uint64")
+	}
+	bigStepHeightBig, err := chalManagerBindings.LAYERZEROBIGSTEPEDGEHEIGHT(&bind.CallOpts{})
+	if err != nil {
+		return nil, fmt.Errorf("could not get big step challenge height: %w", err)
+	}
+	if !bigStepHeightBig.IsUint64() {
+		return nil, errors.New("big step challenge height was not a uint64")
+	}
+	smallStepHeightBig, err := chalManagerBindings.LAYERZEROSMALLSTEPEDGEHEIGHT(&bind.CallOpts{})
+	if err != nil {
+		return nil, fmt.Errorf("could not get small step challenge height: %w", err)
+	}
+	if !smallStepHeightBig.IsUint64() {
+		return nil, errors.New("small step challenge height was not a uint64")
+	}
+	numBigSteps, err := chalManagerBindings.NUMBIGSTEPLEVEL(&bind.CallOpts{})
+	if err != nil {
+		return nil, fmt.Errorf("could not get number of big steps: %w", err)
+	}
+	blockChallengeLeafHeight := l2stateprovider.Height(blockChallengeHeightBig.Uint64())
+	bigStepHeight := l2stateprovider.Height(bigStepHeightBig.Uint64())
+	smallStepHeight := l2stateprovider.Height(smallStepHeightBig.Uint64())
 
 	// Sets up the state provider interface that BOLD will use to request data such as
 	// execution states for assertions, history commitments for machine execution, and one step proofs.
@@ -389,7 +419,7 @@ func newBOLDChallengeManager(
 		return nil, fmt.Errorf("could not create state manager: %w", err)
 	}
 	providerHeights := []l2stateprovider.Height{blockChallengeLeafHeight}
-	for i := uint64(0); i < config.NumBigSteps; i++ {
+	for i := uint8(0); i < numBigSteps; i++ {
 		providerHeights = append(providerHeights, bigStepHeight)
 	}
 	providerHeights = append(providerHeights, smallStepHeight)
@@ -410,7 +440,7 @@ func newBOLDChallengeManager(
 
 	stackOpts := []challengemanager.StackOpt{
 		challengemanager.StackWithName(config.StateProviderConfig.ValidatorName),
-		challengemanager.StackWithMode(BoldModes[config.Mode]),
+		challengemanager.StackWithMode(BoldModes[config.strategy]),
 		challengemanager.StackWithPollingInterval(scanningInterval),
 		challengemanager.StackWithPostingInterval(postingInterval),
 		challengemanager.StackWithConfirmationInterval(confirmingInterval),
@@ -453,7 +483,6 @@ func readBoldAssertionCreationInfo(
 			return nil, errors.New("rollup deployment block was not a uint64")
 		}
 		creationBlock = rollupDeploymentBlock.Uint64()
-		topics = [][]common.Hash{{assertionCreatedId}}
 	} else {
 		var b [32]byte
 		copy(b[:], assertionHash[:])
@@ -462,8 +491,8 @@ func readBoldAssertionCreationInfo(
 			return nil, err
 		}
 		creationBlock = node.CreatedAtBlock
-		topics = [][]common.Hash{{assertionCreatedId}, {assertionHash}}
 	}
+	topics = [][]common.Hash{{assertionCreatedId}, {assertionHash}}
 	var query = ethereum.FilterQuery{
 		FromBlock: new(big.Int).SetUint64(creationBlock),
 		ToBlock:   new(big.Int).SetUint64(creationBlock),

staker/bold/bold_state_provider.go

@@ -75,9 +75,6 @@ func NewBOLDStateProvider(
 // assertion. Returns the state at maxSeqInboxCount or blockChallengeLeafHeight
 // after the previous state, whichever is earlier. If previousGlobalState is
 // nil, defaults to returning the state at maxSeqInboxCount.
-//
-// TODO: Check the block validator has validated the execution state we are
-// proposing.
 func (s *BOLDStateProvider) ExecutionStateAfterPreviousState(
 	ctx context.Context,
 	maxSeqInboxCount uint64,
@@ -373,7 +370,8 @@ func (s *BOLDStateProvider) CollectMachineHashes(
 	}
 	// TODO: Enable Redis streams.
 	wasmModRoot := cfg.AssertionMetadata.WasmModuleRoot
-	execRun, err := s.statelessValidator.ExecutionSpawners()[0].CreateExecutionRun(wasmModRoot, input).Await(ctx)
+	useBoldMachine := true
+	execRun, err := s.statelessValidator.ExecutionSpawners()[0].CreateExecutionRun(wasmModRoot, input, &useBoldMachine).Await(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -458,9 +456,6 @@ func ctxWithCheckAlive(ctxIn context.Context, execRun validator.ExecutionRun) (c
 	// This is to ensure that we do not have the validator froze indefinitely if
 	// the execution run is no longer alive.
 	ctx, cancel := context.WithCancel(ctxIn)
-	// Create a context with cancel, so that we can cancel the check alive routine
-	// once the calling function returns.
-	ctxCheckAlive, cancelCheckAlive := context.WithCancel(ctxIn)
 	go func() {
 		// Call cancel so that the calling function is canceled if the check alive
 		// routine fails/returns.
@@ -469,12 +464,12 @@ func ctxWithCheckAlive(ctxIn context.Context, execRun validator.ExecutionRun) (c
 		defer ticker.Stop()
 		for {
 			select {
-			case <-ctxCheckAlive.Done():
+			case <-ctx.Done():
 				return
 			case <-ticker.C:
 				// Create a context with a timeout, so that the check alive routine does
 				// not run indefinitely.
-				ctxCheckAliveWithTimeout, cancelCheckAliveWithTimeout := context.WithTimeout(ctxCheckAlive, 5*time.Second)
+				ctxCheckAliveWithTimeout, cancelCheckAliveWithTimeout := context.WithTimeout(ctx, 5*time.Second)
 				err := execRun.CheckAlive(ctxCheckAliveWithTimeout)
 				if err != nil {
 					executionNodeOfflineGauge.Inc(1)
@@ -485,7 +480,7 @@ func ctxWithCheckAlive(ctxIn context.Context, execRun validator.ExecutionRun) (c
 			}
 		}
 	}()
-	return ctx, cancelCheckAlive
+	return ctx, cancel
 }
 
 // CollectProof collects a one-step proof at a message number and OpcodeIndex.
@@ -507,6 +502,14 @@ func (s *BOLDStateProvider) CollectProof(
 	if vs.IsSome() {
 		m := server_arb.NewFinishedMachine(vs.Unwrap())
 		defer m.Destroy()
+		log.Info(
+			"Getting machine OSP from virtual state",
+			"fromBatch", assertionMetadata.FromState.Batch,
+			"fromPosInBatch", assertionMetadata.FromState.PosInBatch,
+			"blockChallengeHeight", blockChallengeHeight,
+			"messageNum", messageNum,
+			"machineIndex", machineIndex,
+		)
 		return m.ProveNextStep(), nil
 	}
 	entry, err := s.statelessValidator.CreateReadyValidationEntry(ctx, messageNum)
@@ -527,7 +530,8 @@ func (s *BOLDStateProvider) CollectProof(
 		"startState", fmt.Sprintf("%+v", input.StartState),
 	)
 	wasmModRoot := assertionMetadata.WasmModuleRoot
-	execRun, err := s.statelessValidator.ExecutionSpawners()[0].CreateExecutionRun(wasmModRoot, input).Await(ctx)
+	useBoldMachine := true
+	execRun, err := s.statelessValidator.ExecutionSpawners()[0].CreateExecutionRun(wasmModRoot, input, &useBoldMachine).Await(ctx)
 	if err != nil {
 		return nil, err
 	}

staker/challenge-cache/cache.go

@@ -79,9 +79,8 @@ type Cache struct {
 
 // New cache from a base directory path.
 func New(baseDir string) (*Cache, error) {
-	if _, err := os.Stat(baseDir); err != nil {
-		//nolint:errcheck
-		os.MkdirAll(baseDir, os.ModePerm)
+	if err := os.MkdirAll(baseDir, os.ModePerm); err != nil {
+		return nil, err
 	}
 	// We create a temp directory to write our hashes to first when putting to the cache.
 	// Once writing succeeds, we rename in an atomic operation to the correct file name

staker/legacy/challenge_manager.go

@@ -485,7 +485,8 @@ func (m *ChallengeManager) createExecutionBackend(ctx context.Context, step uint
 	var execRun validator.ExecutionRun
 	for _, spawner := range m.validator.ExecutionSpawners() {
 		if validator.SpawnerSupportsModule(spawner, m.wasmModuleRoot) {
-			execRun, err = spawner.CreateExecutionRun(m.wasmModuleRoot, input).Await(ctx)
+			useBold := false
+			execRun, err = spawner.CreateExecutionRun(m.wasmModuleRoot, input, &useBold).Await(ctx)
 			if err != nil {
 				return fmt.Errorf("error creating execution backend for msg %v: %w", initialCount, err)
 			}