//! Stable updater ownership of the existing SYSTEM ledger. No CREATE, schema //! initialization, replayed activation, replacement ledger or reset is allowed. use crate::{ helper_ipc::{self as ipc, PeerProof, PinnedFile}, signed_clock::BoundClock, update_ipc, update_native::{ Budget, Role, files::{self, Location}, services::Stopped, }, update_original::Original, update_state::{AgentStateFile, Bundle, QualifiedRegistry, RetainedSet}, update_trust::TrustState, }; use anyhow::{Context, Result, ensure}; use fs2::FileExt; use rmm_agent_core::{ auth::Binding, helper_reconcile::ExecutorLedgerGuard, reconcile::SyncClock, update_handoff::{ self as core, NativeEffect, NativeEffectStage, NativeFileRole, NativeService, Participant, UpdateParticipantGuard, }, }; use rmm_domain::{ agent_update::{ParticipantRole, UpdateDelegation}, jobs::hash, }; use rmm_updater_handoff::{Event, Evidence, Handoff, Phase}; use rusqlite::{Connection, OpenFlags}; use std::{cell::RefCell, path::Path, time::Duration}; const ROOT: &str = r"C:\ProgramData\RustDiscoverySystem\state"; const LEDGER: &str = r"C:\ProgramData\RustDiscoverySystem\state\ledger.sqlite"; const LOCK: &str = r"C:\ProgramData\RustDiscoverySystem\state\executor.lock"; const AGENT_LOCK: &str = r"C:\ProgramData\RustDiscovery\state\agent.lock"; /// These are the TWO original locks used by the registered helper and agent, /// acquired only after their exact original instances have terminated. pub struct ClosedFiles { root: RefCell, ledger: RefCell, executor: RefCell, agent: RefCell, } impl ClosedFiles { pub fn acquire(bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>) -> Result { bundle.validate()?; stopped.check(budget)?; let helper = ipc::service_sid(ipc::HELPER_SERVICE)?; let root = PinnedFile::open( Path::new(ROOT), true, &[], std::slice::from_ref(&helper), true, )?; let executor = PinnedFile::open( Path::new(LOCK), false, &[], std::slice::from_ref(&helper), true, )?; ensure!( executor.identity == bundle.ledger.lock, "UPDATE_ORIGINAL_LOCK_IDENTITY" ); executor .file .try_lock_exclusive() .context("UPDATE_ORIGINAL_EXECUTOR_BUSY")?; let agent = AgentStateFile::lock()?; let expected_agent = bundle .retained .iter() .find(|p| p.spec.path == Path::new(AGENT_LOCK)) .context("UPDATE_ORIGINAL_AGENT_LOCK_REQUIRED")?; ensure!( agent.identity == expected_agent.spec.identity, "UPDATE_ORIGINAL_AGENT_LOCK_IDENTITY" ); agent .file .try_lock_exclusive() .context("UPDATE_ORIGINAL_AGENT_BUSY")?; let ledger = PinnedFile::open(Path::new(LEDGER), false, &[], &[helper], true)?; ensure!( ledger.identity == bundle.ledger.ledger, "UPDATE_ORIGINAL_LEDGER_IDENTITY" ); stopped.check(budget)?; let value = Self { root: RefCell::new(root), ledger: RefCell::new(ledger), executor: RefCell::new(executor), agent: RefCell::new(agent), }; value.verify(bundle, stopped, budget)?; Ok(value) } fn verify(&self, bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>) -> Result<()> { stopped.check(budget)?; for file in [&self.root, &self.ledger, &self.executor] { file.try_borrow_mut()?.check()?; } self.agent.try_borrow()?.check()?; ensure!( self.ledger.try_borrow()?.identity == bundle.ledger.ledger && self.executor.try_borrow()?.identity == bundle.ledger.lock, "UPDATE_OWNED_LEDGER_REPLACED" ); Ok(()) } } /// Produced by consuming both actually-held original locks after the SQLite /// connection has closed; the retained handles continue to pin their names. pub struct ReleasedFiles { files: ClosedFiles, } impl ReleasedFiles { pub(crate) fn check(&self, bundle: &Bundle) -> Result<()> { for file in [&self.files.root, &self.files.ledger, &self.files.executor] { file.try_borrow_mut()?.check()?; } self.files.agent.try_borrow()?.check()?; ensure!( self.files.ledger.try_borrow()?.identity == bundle.ledger.ledger && self.files.executor.try_borrow()?.identity == bundle.ledger.lock, "UPDATE_RELEASED_FILES_CHANGED" ); Ok(()) } } impl ClosedFiles { pub fn release( self, bundle: &Bundle, stopped: &Stopped, budget: &Budget<'_>, ) -> Result { self.verify(bundle, stopped, budget)?; FileExt::unlock(&self.executor.try_borrow()?.file)?; FileExt::unlock(&self.agent.try_borrow()?.file)?; let result = ReleasedFiles { files: self }; result.check(bundle)?; Ok(result) } } pub struct Inputs<'a, 'b> { pub closed: &'a ClosedFiles, pub stopped: &'a Stopped, pub bundle: &'a Bundle, pub bundle_recheck: &'a dyn Fn() -> Result<()>, pub original: &'a Original, pub binding: &'a Binding, pub clock: &'a BoundClock, pub budget: &'a Budget<'b>, pub updater: &'a RefCell, pub retained: &'a RetainedSet, pub registry: &'a QualifiedRegistry, pub trust: &'a TrustState, } pub struct Guard<'a, 'b> { input: Inputs<'a, 'b>, sqlite: usize, return_before: Option, } pub struct OwnedLedger<'a, 'b> { db: Connection, guard: Guard<'a, 'b>, } impl<'a, 'b> OwnedLedger<'a, 'b> { pub fn open(input: Inputs<'a, 'b>) -> Result { input .closed .verify(input.bundle, input.stopped, input.budget)?; ensure!( input.bundle.ledger.sha256()? == input.original.handoff().ledger_identity_sha256 && input.retained.sha256()? == input.original.handoff().retained_state_sha256, "UPDATE_ORIGINAL_STATE_BINDING" ); let db = Connection::open_with_flags( LEDGER, OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_NO_MUTEX, )?; db.busy_timeout(Duration::ZERO)?; ensure!( db.query_row("PRAGMA journal_mode", [], |r| r.get::<_, String>(0))? == "delete" && db.query_row("PRAGMA synchronous", [], |r| r.get::<_, u32>(0))? >= 2, "UPDATE_LEDGER_DURABILITY_REQUIRED" ); let sqlite = unsafe { db.handle() } as usize; let (count, max): (usize, Option) = db.query_row( "SELECT count(*),max(length(event)) FROM agent_update_handoff_events WHERE grant_id=?1", [input.original.permit().grant_id.to_string()], |r| Ok((r.get(0)?, r.get(1)?)), )?; ensure!( count <= rmm_updater_handoff::MAX_V2_EVENTS && max.is_none_or(|n| n <= rmm_updater_handoff::MAX_EVENT_BYTES), "UPDATE_ORIGINAL_EVENT_LIMIT" ); let mut query = db.prepare( "SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence", )?; let rows = query .query_map([input.original.permit().grant_id.to_string()], |r| { r.get::<_, Vec>(0) })? .collect::>>()?; drop(query); let mut return_before = None; for raw in rows { let event: Event = serde_json::from_slice(&raw)?; if matches!(event.evidence, Evidence::LedgerReturnIntent) { ensure!( return_before.is_none(), "UPDATE_MULTIPLE_ORIGINAL_RETURN_EVENTS" ); return_before = Some( event .observed_at .checked_add(180) .context("UPDATE_RETURN_DEADLINE_OVERFLOW")?, ); } } let guard = Guard { input, sqlite, return_before, }; guard.check(&db)?; core::read(&db, &guard, guard.input.original.permit().grant_id)?; guard .input .trust .qualify_history(&db, &guard, guard.input.binding)?; db.execute_batch("PRAGMA foreign_keys=ON")?; ensure!( db.query_row("PRAGMA foreign_keys", [], |r| r.get::<_, bool>(0))?, "UPDATE_LEDGER_FOREIGN_KEYS_REQUIRED" ); rmm_agent_core::ledger::bounded_journal_capacity(&db)?; Ok(Self { db, guard }) } pub fn record_stops( &mut self, observations: crate::update_native::control_fence::StopObservations, ) -> Result<()> { self.guard.effect_window()?; ensure!( self.guard.input.stopped.proofs() == observations.proofs, "UPDATE_STOP_SOURCE_CHANGED" ); for (claim, observed) in observations.claims.iter().zip(&observations.observations) { core::observe_native_effect( &mut self.db, &self.guard, claim, observed, self.guard.input.clock.reading()?.upper, )?; } self.append(Evidence::AllStopped { observation_sha256: hash(&serde_json::to_vec(self.guard.input.stopped.proofs())?), })?; let owner = &self.guard.input.original.delegation().updater; self.append(Evidence::UpdaterOwnsLedger { process: rmm_updater_handoff::Process { pid: owner.pid, birth: owner.birth, image_sha256: owner.image_sha256.clone(), }, ledger_identity_sha256: self.guard.input.bundle.ledger.sha256()?, }) } fn append(&mut self, evidence: Evidence) -> Result<()> { let grant = self.guard.input.original.permit().grant_id; let journal = core::read(&self.db, &self.guard, grant)?; let event = journal.prepare( u64::try_from(self.guard.input.clock.reading()?.upper.timestamp())?, evidence, )?; core::append( &mut self.db, &self.guard, grant, journal.head_sha256(), &event, ) } pub fn prepare_return_and_close( mut self, ) -> Result { self.guard.effect_window()?; let grant = self.guard.input.original.permit().grant_id; let journal = core::read(&self.db, &self.guard, grant)?; ensure!( journal.phase() == Phase::PairVerified, "UPDATE_VERIFIED_PAIR_REQUIRED" ); let now = self.guard.input.clock.reading()?.upper; let event = journal.prepare( u64::try_from(now.timestamp())?, Evidence::LedgerReturnIntent, )?; let claims = core::prepare_windows_return_and_starts( &mut self.db, &self.guard, grant, journal.head_sha256(), &event, now, )?; let proof = core::current_proof(&self.db, &self.guard, grant)? .context("UPDATE_RETURN_PREFIX_REQUIRED")?; self.close()?; Ok( crate::update_native::control_fence::PreparedStart::after_closed_connection( claims, proof, ), ) } pub fn parts(&mut self) -> (&mut Connection, &Guard<'a, 'b>) { (&mut self.db, &self.guard) } pub fn close(self) -> Result<()> { self.guard.check(&self.db)?; self.db.close().map_err(|(_, error)| error)?; self.guard.input.closed.verify( self.guard.input.bundle, self.guard.input.stopped, self.guard.input.budget, ) } } impl Guard<'_, '_> { fn current(&self) -> Result<()> { let i = &self.input; (i.bundle_recheck)()?; i.closed.verify(i.bundle, i.stopped, i.budget)?; Original::verify_retained( i.binding, i.original.start_bytes(), &i.original.handoff().bytes()?, i.original.delegation().clone(), )?; i.trust.recheck_protected()?; let updater_pin = crate::update_native::services::updater_pin(i.trust.policy())?; let updater_configuration = crate::update_native::services::updater_configuration_sha256(&updater_pin)?; ensure!( updater_configuration == i.trust.policy().updater_service.unit_sha256, "UPDATE_UPDATER_CONFIGURATION_CHANGED" ); i.registry .verify_observed(i.stopped.proofs(), &updater_configuration)?; i.retained.verify()?; let mut updater = i.updater.try_borrow_mut()?; updater.check()?; ensure!( update_ipc::participant(&updater, ParticipantRole::WindowsUpdater)? == i.original.delegation().updater, "UPDATE_ORIGINAL_UPDATER_PROCESS_CHANGED" ); Ok(()) } fn effect_window(&self) -> Result<()> { self.current()?; let i = &self.input; i.original.check_current(i.binding, i.clock, i.budget)?; if let Some(until) = self.return_before { ensure!( u64::try_from(i.clock.reading()?.upper.timestamp())? < until, "UPDATE_ORIGINAL_HEALTH_WINDOW_EXPIRED" ); } i.trust.recheck_prepared(i.original.update(), i.clock) } fn same(&self, h: &Handoff, d: &UpdateDelegation) -> Result<()> { ensure!( h.bytes()? == self.input.original.handoff().bytes()? && d == self.input.original.delegation(), "UPDATE_ORIGINAL_OWNER_CHANGED" ); self.current() } fn file(&self, role: Role, location: Location, candidate: bool) -> Result<()> { let bound = self .input .bundle .files .iter() .find(|v| v.role == role) .context("UPDATE_ORIGINAL_ROLE_REQUIRED")?; let expected = if candidate { &bound.staged } else { &bound.original }; ensure!( files::observe_bound( role, self.input.original.handoff().owner_nonce, location, self.input.budget )? == *expected, "UPDATE_OWNED_FILE_CHANGED" ); Ok(()) } fn pair(&self, candidate: bool) -> Result<()> { for f in &self.input.bundle.files { self.file(f.role, Location::Target, candidate)?; self.file( f.role, if candidate { Location::Previous } else { Location::Rejected }, !candidate, )?; } Ok(()) } } impl ExecutorLedgerGuard for Guard<'_, '_> { fn check(&self, db: &Connection) -> Result<()> { self.current()?; self.input .stopped .verify_failure_claims(db, self.input.original.handoff())?; ensure!( unsafe { db.handle() } as usize == self.sqlite && db.path() == Some(LEDGER), "UPDATE_OWNED_SQLITE_CONNECTION_CHANGED" ); let start: Vec = db.query_row( "SELECT start FROM execution_evidence WHERE grant_id=?1", [self.input.original.permit().grant_id.to_string()], |r| r.get(0), )?; ensure!( start == self.input.original.start_bytes(), "UPDATE_ORIGINAL_START_CHANGED" ); let other: u64 = db.query_row( "SELECT count(*) FROM consumed WHERE result IS NULL AND grant_id<>?1", [self.input.original.permit().grant_id.to_string()], |r| r.get(0), )?; ensure!(other == 0, "UPDATE_OTHER_UNRESOLVED_ATTEMPT"); Ok(()) } fn check_update_owner( &self, h: &Handoff, d: &UpdateDelegation, phase: Phase, _events: &[Event], ) -> Result<()> { ensure!( !matches!( phase, Phase::HandoffConsumed | Phase::ServicesStarted | Phase::HealthVerified | Phase::RollbackServicesStarted | Phase::RollbackHealthVerified | Phase::OutcomePersisted ), "UPDATE_STABLE_WRITER_PHASE" ); self.same(h, d)?; self.effect_window() } } fn role(r: NativeFileRole) -> Result { Ok(match r { NativeFileRole::AgentBinary => Role::Agent, NativeFileRole::HelperBinary => Role::Helper, NativeFileRole::WindowsSettings => Role::Settings, NativeFileRole::WindowsPin => Role::Pin, NativeFileRole::WindowsTimeProfile => Role::TimeProfile, _ => anyhow::bail!("UPDATE_WINDOWS_FILE_ROLE_REQUIRED"), }) } impl UpdateParticipantGuard for Guard<'_, '_> { fn participant(&self) -> Participant { Participant::StableUpdater } fn verify_native_effect( &self, h: &Handoff, d: &UpdateDelegation, effect: &NativeEffect, stage: NativeEffectStage, ) -> Result<()> { self.same(h, d)?; self.effect_window()?; match (effect, stage) { ( NativeEffect::StartService { .. } | NativeEffect::RollbackStopService { .. }, NativeEffectStage::ObserveNonstart, ) => self .input .stopped .failure_observation(h, d, effect, self.input.budget) .map(|_| ()), (NativeEffect::StopService { service }, NativeEffectStage::Observe) => { let expected = match service { NativeService::WindowsAgent => super::update_native::Service::Agent, NativeService::WindowsHelper => super::update_native::Service::Helper, _ => anyhow::bail!("UPDATE_WINDOWS_SERVICE_REQUIRED"), }; ensure!( self.input .stopped .proofs() .iter() .any(|p| p.configuration.service == expected), "UPDATE_STOPPED_ORIGINAL_SERVICE_REQUIRED" ); self.input.stopped.check(self.input.budget) } (NativeEffect::SavePredecessor { role: r }, NativeEffectStage::Claim) => { self.file(role(*r)?, Location::Target, false)?; self.file(role(*r)?, Location::Stage, true) } (NativeEffect::SavePredecessor { role: r }, NativeEffectStage::Observe) => { self.file(role(*r)?, Location::Previous, false) } (NativeEffect::PublishReplacement { role: r }, NativeEffectStage::Claim) => { self.file(role(*r)?, Location::Previous, false)?; self.file(role(*r)?, Location::Stage, true) } (NativeEffect::PublishReplacement { role: r }, NativeEffectStage::Observe) => { self.file(role(*r)?, Location::Target, true) } (NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Claim) => { self.file(role(*r)?, Location::Target, true)?; self.file(role(*r)?, Location::Previous, false) } (NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Observe) => { self.file(role(*r)?, Location::Rejected, true) } (NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Claim) => { self.file(role(*r)?, Location::Previous, false)?; self.file(role(*r)?, Location::Rejected, true) } (NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Observe) => { self.file(role(*r)?, Location::Target, false) } (NativeEffect::ReturnLedger, NativeEffectStage::Claim) => self.pair(true), (NativeEffect::RollbackReturnLedger, NativeEffectStage::Claim) => self.pair(false), ( NativeEffect::StartService { service: NativeService::WindowsHelper | NativeService::WindowsAgent, }, NativeEffectStage::ReserveFutureStart, ) => self.pair(true), ( NativeEffect::RollbackStartService { service: NativeService::WindowsHelper | NativeService::WindowsAgent, }, NativeEffectStage::ReserveFutureStart, ) => self.pair(false), _ => anyhow::bail!("UPDATE_WINDOWS_OWNED_EFFECT_NOT_QUALIFIED"), } } fn native_observation_sha256( &self, h: &Handoff, d: &UpdateDelegation, effect: &NativeEffect, stage: NativeEffectStage, ) -> Result { self.same(h, d)?; self.effect_window()?; ensure!( stage == NativeEffectStage::ObserveNonstart, "UPDATE_KNOWN_NONSTART_STAGE_REQUIRED" ); self.input .stopped .failure_observation(h, d, effect, self.input.budget) } fn verify_update_event(&self, h: &Handoff, d: &UpdateDelegation, event: &Event) -> Result<()> { self.same(h, d)?; if matches!(event.evidence, Evidence::Unknown { .. }) { return Ok(()); } self.effect_window()?; match &event.evidence { Evidence::AllStopped { observation_sha256 } => ensure!( *observation_sha256 == hash(&serde_json::to_vec(self.input.stopped.proofs())?), "UPDATE_STOPPED_OBSERVATION_CHANGED" ), Evidence::UpdaterOwnsLedger { process, ledger_identity_sha256, } => ensure!( process.pid == d.updater.pid && process.birth == d.updater.birth && process.image_sha256 == d.updater.image_sha256 && *ledger_identity_sha256 == self.input.bundle.ledger.sha256()?, "UPDATE_UPDATER_OWNER_OBSERVATION_CHANGED" ), Evidence::ReplaceIntent { role: r } => { let r = self .input .bundle .files .iter() .find(|v| v.role.handoff_role() == *r) .context("UPDATE_ORIGINAL_ROLE_REQUIRED")? .role; self.file(r, Location::Target, false)?; self.file(r, Location::Stage, true)?; } Evidence::Replaced { role: r, observed_sha256, } => { let f = self .input .bundle .files .iter() .find(|v| v.role.handoff_role() == *r) .context("UPDATE_ORIGINAL_ROLE_REQUIRED")?; ensure!( *observed_sha256 == f.staged.sha256, "UPDATE_REPLACED_HASH_CHANGED" ); self.file(f.role, Location::Target, true)?; self.file(f.role, Location::Previous, false)?; } Evidence::PairVerified { pair, retained_state_sha256, } => { ensure!( *pair == h.target && *retained_state_sha256 == self.input.retained.sha256()?, "UPDATE_PAIR_OBSERVATION_CHANGED" ); self.pair(true)?; } Evidence::LedgerReturnIntent => self.pair(true)?, Evidence::RollbackIntent { cause: rmm_updater_handoff::RollbackCause::StartupFailed { service: rmm_updater_handoff::Service::WindowsHelper, }, failure_observation_sha256, } => { let failed = self .input .stopped .failed_start() .context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?; ensure!( *failure_observation_sha256 == failed.sha256()?, "UPDATE_ACTUAL_HELPER_FAILURE_CHANGED" ); self.input.stopped.failure_observation( h, d, &NativeEffect::StartService { service: NativeService::WindowsHelper, }, self.input.budget, )?; self.pair(true)?; } Evidence::RollbackStopped { process, ledger_identity_sha256, observation_sha256, } => { let failed = self .input .stopped .failed_start() .context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?; ensure!( process.pid == d.updater.pid && process.birth == d.updater.birth && process.image_sha256 == d.updater.image_sha256 && *ledger_identity_sha256 == self.input.bundle.ledger.sha256()? && *observation_sha256 == hash(&serde_json::to_vec(&(failed, self.input.stopped.proofs()))?), "UPDATE_ACTUAL_ROLLBACK_STOPPED_CHANGED" ); self.input.stopped.check(self.input.budget)?; } Evidence::RestoreIntent { role: r } | Evidence::CandidatePreserved { role: r, .. } | Evidence::PredecessorRestored { role: r, .. } => { let bound = self .input .bundle .files .iter() .find(|f| f.role.handoff_role() == *r) .context("UPDATE_ORIGINAL_RESTORE_ROLE_REQUIRED")?; match &event.evidence { Evidence::RestoreIntent { .. } => { self.file(bound.role, Location::Target, true)?; self.file(bound.role, Location::Previous, false)?; } Evidence::CandidatePreserved { observation_sha256, .. } => { self.file(bound.role, Location::Rejected, true)?; self.file(bound.role, Location::Previous, false)?; ensure!( *observation_sha256 == hash(&serde_json::to_vec(&bound.staged)?), "UPDATE_ACTUAL_PRESERVED_CANDIDATE_CHANGED" ); } Evidence::PredecessorRestored { observed_sha256, .. } => { self.file(bound.role, Location::Target, false)?; self.file(bound.role, Location::Rejected, true)?; ensure!( *observed_sha256 == bound.original.sha256, "UPDATE_ACTUAL_RESTORED_PREDECESSOR_CHANGED" ); } _ => unreachable!(), } } Evidence::PredecessorVerified { pair, retained_state_sha256, predecessor_record_sha256, } => { ensure!( *pair == h.predecessor && *retained_state_sha256 == self.input.retained.sha256()? && *predecessor_record_sha256 == hash(self.input.trust.installed_raw()), "UPDATE_PREDECESSOR_OBSERVATION_CHANGED" ); self.pair(false)?; } Evidence::RollbackLedgerReturnIntent => self.pair(false)?, // Failed-start/rollback events require a retained native failure // source; a caller-provided reason or hash is never sufficient. _ => anyhow::bail!("UPDATE_WINDOWS_OWNED_EVENT_NOT_QUALIFIED"), } Ok(()) } } impl OwnedLedger<'_, '_> { pub fn begin_failed_helper_rollback(&mut self) -> Result<()> { self.guard.effect_window()?; let failed = self .guard .input .stopped .failed_start() .context("UPDATE_KNOWN_HELPER_FAILURE_REQUIRED")?; ensure!( failed.service() == crate::update_native::Service::Helper, "UPDATE_HELPER_FAILURE_REQUIRED" ); let grant = self.guard.input.original.permit().grant_id; let journal = core::read(&self.db, &self.guard, grant)?; core::begin_rollback( &mut self.db, &self.guard, grant, journal.head_sha256(), &rmm_updater_handoff::RollbackCause::StartupFailed { service: rmm_updater_handoff::Service::WindowsHelper, }, &failed.sha256()?, self.guard.input.clock.reading()?.upper, )?; let owner = &self.guard.input.original.delegation().updater; self.append(Evidence::RollbackStopped { process: rmm_updater_handoff::Process { pid: owner.pid, birth: owner.birth, image_sha256: owner.image_sha256.clone(), }, ledger_identity_sha256: self.guard.input.bundle.ledger.sha256()?, observation_sha256: hash(&serde_json::to_vec(&( failed, self.guard.input.stopped.proofs(), ))?), }) } pub fn prepare_rollback_return_and_close( mut self, ) -> Result { self.guard.effect_window()?; let grant = self.guard.input.original.permit().grant_id; let journal = core::read(&self.db, &self.guard, grant)?; ensure!( journal.phase() == Phase::PredecessorVerified, "UPDATE_VERIFIED_PREDECESSOR_REQUIRED" ); let now = self.guard.input.clock.reading()?.upper; let event = journal.prepare( u64::try_from(now.timestamp())?, Evidence::RollbackLedgerReturnIntent, )?; let claims = core::prepare_windows_rollback_return_and_starts( &mut self.db, &self.guard, grant, journal.head_sha256(), &event, now, )?; let proof = core::current_proof(&self.db, &self.guard, grant)? .context("UPDATE_ROLLBACK_RETURN_PREFIX_REQUIRED")?; self.close()?; Ok( crate::update_native::control_fence::PreparedStart::after_closed_connection( claims, proof, ), ) } }