Bold fixes

arbitrator/prover/src/lib.rs

@@ -127,6 +127,12 @@ pub unsafe extern "C" fn arbitrator_load_wavm_binary(binary_path: *const c_char)
     }
 }
 
+#[no_mangle]
+#[cfg(feature = "native")]
+pub unsafe extern "C" fn arbitrator_new_finished() -> *mut Machine {
+    Box::into_raw(Box::new(Machine::new_finished()))
+}
+
 unsafe fn cstr_to_string(c_str: *const c_char) -> String {
     CStr::from_ptr(c_str).to_string_lossy().into_owned()
 }

arbitrator/prover/src/machine.rs

@@ -1565,6 +1565,39 @@ impl Machine {
         Ok(mach)
     }
 
+    // new_finished returns a Machine in the Finished state at step 0.
+    //
+    // This allows the Mahine to be set up to model the final state of the
+    // machine at the end of the execution of a block.
+    //
+    // Callers should use set_global_state to set the global state of the
+    // machine to the global state at the end of the block.
+    pub fn new_finished() -> Machine {
+        Machine {
+            steps: 0,
+            status: MachineStatus::Finished,
+            global_state: Default::default(),
+            // The machine is in the Finished state, so nothing else really matters.
+            // values_stacks and frame_stacks cannot be empty for proof serialization,
+            // but everything else can just be entirely blank.
+            thread_state: ThreadState::Main,
+            value_stacks: vec![Vec::new()],
+            frame_stacks: vec![Vec::new()],
+            internal_stack: Default::default(),
+            modules: Default::default(),
+            modules_merkle: Default::default(),
+            pc: Default::default(),
+            stdio_output: Default::default(),
+            inbox_contents: Default::default(),
+            first_too_far: Default::default(),
+            preimage_resolver: PreimageResolverWrapper::new(Arc::new(|_, _, _| None)),
+            stylus_modules: Default::default(),
+            initial_hash: Default::default(),
+            context: Default::default(),
+            debug_info: Default::default(),
+        }
+    }
+
     pub fn new_from_wavm(wavm_binary: &Path) -> Result<Machine> {
         let mut modules: Vec<Module> = {
             let compressed = std::fs::read(wavm_binary)?;
@@ -2867,6 +2900,15 @@ impl Machine {
         let mod_merkle = self.get_modules_merkle();
         out!(mod_merkle.root());
 
+        if self.is_halted() {
+            // If the machine is halted, instead of serializing the module,
+            // serialize the global state and return.
+            // This is for the "kickstart" BoLD proof, but it's backwards compatible
+            // with the old OSP behavior which reads no further.
+            out!(self.global_state.serialize());
+            return data;
+        }
+
         // End machine serialization, serialize module
 
         let module = &self.modules[self.pc.module()];

cmd/nitro-val/nitro_val.go

@@ -135,6 +135,7 @@ func mainImpl() int {
 		func() *valnode.Config { return &liveNodeConfig.Get().Validation },
 		stack,
 		fatalErrChan,
+		nil,
 	)
 	if err != nil {
 		log.Error("couldn't init validation node", "err", err)

cmd/nitro/nitro.go

@@ -513,6 +513,7 @@ func mainImpl() int {
 			func() *valnode.Config { return &liveNodeConfig.Get().Validation },
 			stack,
 			fatalErrChan,
+			nil,
 		)
 		if err != nil {
 			valNode = nil

staker/bold/bold_staker.go

@@ -1,6 +1,6 @@
 // Copyright 2023, Offchain Labs, Inc.
 // For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
-package boldstaker
+package bold
 
 import (
 	"context"
@@ -394,31 +394,28 @@ func newBOLDChallengeManager(
 	scanningInterval := config.AssertionScanningInterval
 	// The interval at which the manager will attempt to confirm assertions.
 	confirmingInterval := config.AssertionConfirmingInterval
-	opts := []challengemanager.Opt{
-		challengemanager.WithName(config.StateProviderConfig.ValidatorName),
-		challengemanager.WithMode(BoldModes[config.Mode]),
-		challengemanager.WithAssertionPostingInterval(postingInterval),
-		challengemanager.WithAssertionScanningInterval(scanningInterval),
-		challengemanager.WithAssertionConfirmingInterval(confirmingInterval),
-		challengemanager.WithAddress(txOpts.From),
-		// Configure the validator to track only certain challenges if configured to do so.
-		challengemanager.WithTrackChallengeParentAssertionHashes(config.TrackChallengeParentAssertionHashes),
+
+	stackOpts := []challengemanager.StackOpt{
+		challengemanager.StackWithName(config.StateProviderConfig.ValidatorName),
+		challengemanager.StackWithMode(BoldModes[config.Mode]),
+		challengemanager.StackWithPollingInterval(scanningInterval),
+		challengemanager.StackWithPostingInterval(postingInterval),
+		challengemanager.StackWithConfirmationInterval(confirmingInterval),
+		challengemanager.StackWithTrackChallengeParentAssertionHashes(config.TrackChallengeParentAssertionHashes),
 	}
 	if config.API {
-		// Conditionally enables the BOLD API if configured.
-		opts = append(opts, challengemanager.WithAPIEnabled(fmt.Sprintf("%s:%d", config.APIHost, config.APIPort), config.APIDBPath))
+		apiAddr := fmt.Sprintf("%s:%d", config.APIHost, config.APIPort)
+		stackOpts = append(stackOpts, challengemanager.StackWithAPIEnabled(apiAddr, config.APIDBPath))
 	}
-	manager, err := challengemanager.New(
-		ctx,
+
+	manager, err := challengemanager.NewChallengeStack(
 		assertionChain,
 		provider,
-		assertionChain.RollupAddress(),
-		opts...,
+		stackOpts...,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("could not create challenge manager: %w", err)
 	}
-	provider.UpdateAPIDatabase(manager.Database())
 	return manager, nil
 }