#include "evo/persistence/checkpoint_store.hpp" #include "evo/persistence/sha256.hpp" #include #include #include #include #include namespace evo::persistence { namespace { using std::chrono::milliseconds; std::uint64_t input_tick(const server::CellularActionRecord& action) { std::uint64_t tick{}; for (std::size_t i = 0; i < 8; ++i) tick |= static_cast(action.input[i]) << (i * 8U); return tick; } CellularPublicationFailure failure(PublicationError kind, ObjectError object = {}, LeaseStoreFailure store = {}, CellularPreparedCommit prepared = {}) { return {kind, store, object, std::move(prepared)}; } CellularProfileMigrationFailure migration_failure(PublicationError kind, ObjectError object = {}, LeaseStoreFailure store = {}, CellularProfileMigrationPrepared prepared = {}) { return {kind, store, object, std::move(prepared)}; } std::expected put_verified(const FilesystemObjectStore& objects, std::span bytes, VerifiedObject expected) { auto stored = objects.put(bytes); if (!stored) return std::unexpected{failure(PublicationError::upload, stored.error())}; auto readback = objects.get(*stored); if (!readback || *stored != expected || !std::ranges::equal(*readback, bytes)) return std::unexpected{ failure(PublicationError::verify, readback ? ObjectError::corrupt : readback.error())}; return {}; } std::expected confirm(const RegionHead& head, const CellularPreparedCommit& prepared, const CheckpointManifest& manifest) { const auto digest = sha256(prepared.manifest); if (!digest || head.digest != *digest || head.sequence != manifest.sequence || head.commit != manifest.commit || head.end_tick != manifest.end_tick || head.frame != manifest.frame) return std::unexpected{failure(PublicationError::receipt)}; return CommittedCheckpoint{head, prepared.manifest}; } bool prepared_is_canonical(const CellularPreparedCommit& prepared, const CheckpointManifest& manifest, const server::CellularBatch& trace) { const auto decoded_actions = server::decode_cellular_action_block( prepared.actions, manifest.begin_tick, manifest.end_tick); const auto encoded_actions = decoded_actions ? server::encode_cellular_action_block(*decoded_actions, manifest.begin_tick, manifest.end_tick) : std::expected, server::CellularActionBlockError>{ std::unexpected{server::CellularActionBlockError::format}}; const auto encoded_trace = server::encode_cellular_batch(trace); const auto digest = sha256(prepared.trace); return manifest.profile == CheckpointProfile::cellular_lives_v1 && manifest.key == prepared.key && manifest.commit == prepared.commit && manifest.sequence > 0 && manifest.batch.trace_bytes == prepared.trace.size() && digest && *digest == manifest.batch.trace_sha256 && manifest.batch.decision_count == 0 && manifest.batch.decisions_sha256 == Sha256Digest{} && trace.header.world == prepared.key.world && trace.header.region == prepared.key.region && trace.header.frame == manifest.frame && trace.header.predecessor == manifest.predecessor_commit && trace.header.predecessor_digest == manifest.predecessor_digest && trace.header.begin_tick == manifest.begin_tick && trace.header.end_tick == manifest.end_tick && encoded_actions && *encoded_actions == prepared.actions && encoded_trace && *encoded_trace == prepared.trace; } } // namespace std::expected provision_cellular_region(Postgres& owner, const FilesystemObjectStore& objects, RegionKey key, std::uint64_t frame, const server::CellularLives& opening, Uuid commit, const Sha256Digest& build, milliseconds timeout) { const auto payload = opening.snapshot(); if (opening.world() != key.world || opening.region() != key.region || opening.frame() != frame || opening.tick() != 0 || !opening.lives().empty() || !opening.corpses().empty() || opening.archive().recorded() != 0 || opening.archive().archived() != 0) return std::unexpected{failure(PublicationError::candidate)}; const auto digest = sha256(payload); if (!digest) return std::unexpected{failure(PublicationError::digest)}; auto manifest = genesis_manifest(key, frame, commit, biology::cellular_motion_tick_microseconds, build, payload.size(), *digest, CheckpointProfile::cellular_lives_v1); if (manifest && opening.format_version() == server::cellular_lives_format && opening.rules_version() == server::cellular_lives_rules) manifest->cellular_versions = cellular_v2_versions; else if (manifest && (opening.format_version() != server::cellular_lives_legacy_format || opening.rules_version() != 1)) return std::unexpected{failure(PublicationError::candidate)}; auto encoded = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!encoded || !restore_cellular_payload(payload, *manifest)) return std::unexpected{failure(PublicationError::candidate)}; if (auto stored = put_verified(objects, payload, {*digest, payload.size()}); !stored) return std::unexpected{stored.error()}; std::string manifest_hex = "\\x"; constexpr std::string_view digits = "0123456789abcdef"; manifest_hex.reserve(2 + encoded->size() * 2); for (const auto byte : *encoded) { manifest_hex.push_back(digits[byte >> 4U]); manifest_hex.push_back(digits[byte & 0x0fU]); } const std::array parameters{std::move(manifest_hex)}; auto inserted = owner.query("SELECT evolution.provision_region_checkpoint($1::bytea)", parameters, timeout); if (!inserted) { auto existing = load_region_checkpoint(owner, key, timeout); if (existing && existing->manifest == *encoded) return confirm(existing->head, CellularPreparedCommit{key, commit, *encoded, {}, {}}, *manifest); if (existing) return std::unexpected{failure(PublicationError::rejected)}; if (existing.error().kind != LeaseStoreError::not_provisioned && inserted.error().kind == PgError::unknown) return std::unexpected{failure(PublicationError::unknown, {}, existing.error())}; const bool unknown = inserted.error().kind == PgError::unknown; return std::unexpected{failure( unknown ? PublicationError::unknown : PublicationError::rejected, {}, {unknown ? LeaseStoreError::unknown : LeaseStoreError::store, inserted.error()})}; } auto committed = load_region_checkpoint(owner, key, timeout); if (!committed) return std::unexpected{failure(PublicationError::unknown, {}, committed.error())}; CellularPreparedCommit prepared{key, commit, *encoded, {}, {}}; auto confirmed = confirm(committed->head, prepared, *manifest); if (!confirmed) return std::unexpected{confirmed.error()}; return *confirmed; } std::expected retry_cellular_profile_migration(Postgres& db, const CellularProfileMigrationPrepared& prepared, milliseconds timeout) { const auto manifest = decode_manifest(prepared.manifest); if (!manifest || manifest->key != prepared.key || manifest->commit != prepared.commit || manifest->profile != CheckpointProfile::cellular_lives_v1 || (manifest->cellular_versions != cellular_v2_versions && manifest->cellular_versions != cellular_v3_versions) || manifest->begin_tick != manifest->end_tick || manifest->batch != BatchDigests{}) return std::unexpected{migration_failure(PublicationError::candidate, {}, {}, prepared)}; const auto confirm_commit = [&](const RegionHead& head) { const auto digest = sha256(prepared.manifest); if (!digest || head.sequence != manifest->sequence || head.commit != manifest->commit || head.digest != *digest || head.end_tick != manifest->end_tick || head.frame != manifest->frame) return std::expected{ std::unexpected{migration_failure(PublicationError::receipt, {}, {}, prepared)}}; return std::expected{ CommittedCheckpoint{head, prepared.manifest}}; }; auto published = publish_cellular_profile_migration(db, prepared.manifest, timeout); if (published) return confirm_commit(*published); if (published.error().kind == LeaseStoreError::unknown) { const auto stored = load_region_commit(db, prepared.key, manifest->sequence, timeout); if (stored && stored->manifest == prepared.manifest) return confirm_commit(stored->head); if (!stored && stored.error().kind != LeaseStoreError::not_provisioned) return std::unexpected{ migration_failure(PublicationError::unknown, {}, stored.error(), prepared)}; return std::unexpected{ migration_failure(PublicationError::unknown, {}, published.error(), prepared)}; } return std::unexpected{ migration_failure(PublicationError::rejected, {}, published.error(), prepared)}; } std::expected migrate_cellular_profile_to_v2(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, Uuid commit, const Sha256Digest& build, milliseconds timeout) { const auto previous = decode_manifest(predecessor.manifest); const auto previous_digest = sha256(predecessor.manifest); if (!previous || !previous_digest || previous->profile != CheckpointProfile::cellular_lives_v1 || previous->cellular_versions != cellular_v1_versions || predecessor.head.digest != *previous_digest || predecessor.head.sequence != previous->sequence || predecessor.head.commit != previous->commit || predecessor.head.end_tick != previous->end_tick || lease.frame != previous->frame || previous->sequence == 0 || previous->end_tick == 0) return std::unexpected{migration_failure(PublicationError::candidate)}; auto source_payload = objects.get({previous->payload_sha256, previous->payload_bytes}); if (!source_payload) return std::unexpected{ migration_failure(PublicationError::predecessor, source_payload.error())}; const auto source_digest = sha256(*source_payload); if (!source_digest || *source_digest != previous->payload_sha256) return std::unexpected{ migration_failure(PublicationError::predecessor, ObjectError::corrupt)}; auto source = restore_cellular_payload(*source_payload, *previous); if (!source || (*source)->format_version() != server::cellular_lives_legacy_format || (*source)->rules_version() != 1) return std::unexpected{migration_failure(PublicationError::predecessor)}; auto migrated = (*source)->migrate_to_v2(); if (!migrated || (*migrated)->tick() != (*source)->tick() || (*migrated)->current_total() != (*source)->current_total()) return std::unexpected{migration_failure(PublicationError::candidate)}; const auto payload = (*migrated)->snapshot(); const auto payload_digest = sha256(payload); if (!payload_digest) return std::unexpected{migration_failure(PublicationError::digest)}; auto manifest = cellular_profile_migration_manifest(*previous, *previous_digest, commit, lease, build, payload.size(), *payload_digest); auto encoded = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!encoded || !restore_cellular_payload(payload, *manifest)) return std::unexpected{migration_failure(PublicationError::candidate)}; if (auto stored = put_verified(objects, payload, {*payload_digest, payload.size()}); !stored) return std::unexpected{migration_failure(stored.error().kind, stored.error().object)}; return retry_cellular_profile_migration( db, CellularProfileMigrationPrepared{previous->key, commit, std::move(*encoded)}, timeout); } std::expected migrate_cellular_profile_to_v3(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, Uuid commit, const Sha256Digest& build, milliseconds timeout) { const auto previous = decode_manifest(predecessor.manifest); const auto previous_digest = sha256(predecessor.manifest); if (!previous || !previous_digest || previous->profile != CheckpointProfile::cellular_lives_v1 || previous->cellular_versions != cellular_v2_versions || predecessor.head.digest != *previous_digest || predecessor.head.sequence != previous->sequence || predecessor.head.commit != previous->commit || predecessor.head.end_tick != previous->end_tick || lease.frame != previous->frame || previous->sequence == 0 || previous->end_tick == 0) return std::unexpected{migration_failure(PublicationError::candidate)}; auto source_payload = objects.get({previous->payload_sha256, previous->payload_bytes}); if (!source_payload) return std::unexpected{ migration_failure(PublicationError::predecessor, source_payload.error())}; const auto source_digest = sha256(*source_payload); if (!source_digest || *source_digest != previous->payload_sha256) return std::unexpected{ migration_failure(PublicationError::predecessor, ObjectError::corrupt)}; auto source = restore_cellular_payload(*source_payload, *previous); if (!source || (*source)->format_version() != server::cellular_lives_format || (*source)->rules_version() != server::cellular_lives_rules) return std::unexpected{migration_failure(PublicationError::predecessor)}; auto migrated = (*source)->migrate_to_v3(); if (!migrated || (*migrated)->tick() != (*source)->tick() || (*migrated)->current_total() != (*source)->current_total()) return std::unexpected{migration_failure(PublicationError::candidate)}; const auto payload = (*migrated)->snapshot(); const auto payload_digest = sha256(payload); if (!payload_digest) return std::unexpected{migration_failure(PublicationError::digest)}; auto manifest = cellular_profile_migration_manifest(*previous, *previous_digest, commit, lease, build, payload.size(), *payload_digest); auto encoded = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!encoded || !restore_cellular_payload(payload, *manifest)) return std::unexpected{migration_failure(PublicationError::candidate)}; if (auto stored = put_verified(objects, payload, {*payload_digest, payload.size()}); !stored) return std::unexpected{migration_failure(stored.error().kind, stored.error().object)}; return retry_cellular_profile_migration( db, CellularProfileMigrationPrepared{previous->key, commit, std::move(*encoded)}, timeout); } std::expected retry_cellular_prepared(Postgres& db, const CellularPreparedCommit& prepared, milliseconds timeout) { auto manifest = decode_manifest(prepared.manifest); auto trace = server::decode_cellular_batch(prepared.trace); if (!manifest || !trace || !prepared_is_canonical(prepared, *manifest, *trace)) return std::unexpected{failure(PublicationError::candidate)}; auto result = publish_cellular_checkpoint(db, prepared.manifest, {}, prepared.actions, prepared.trace, timeout); if (!result) { return std::unexpected{failure(result.error().kind == LeaseStoreError::unknown ? PublicationError::unknown : PublicationError::rejected, {}, result.error(), prepared)}; } return confirm(*result, prepared, *manifest); } std::expected resolve_cellular_prepared(Postgres& db, const CellularPreparedCommit& prepared, milliseconds timeout) { auto manifest = decode_manifest(prepared.manifest); auto trace = server::decode_cellular_batch(prepared.trace); if (!manifest || !trace || !prepared_is_canonical(prepared, *manifest, *trace)) return std::unexpected{LeaseStoreFailure{LeaseStoreError::invalid, {}}}; return resolve_cellular_region_commit(db, prepared.key, prepared.commit, prepared.manifest, {}, prepared.actions, prepared.trace, timeout); } std::expected publish_cellular_batch(Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease, const CommittedCheckpoint& predecessor, const server::CellularBatch& batch, const server::CellularLives& candidate, Uuid commit, const Sha256Digest& build, milliseconds timeout, const PublishHooks& hooks, std::span actions) { const auto previous = decode_manifest(predecessor.manifest); const auto predecessor_digest = sha256(predecessor.manifest); const auto trace = server::encode_cellular_batch(batch); const auto action_block = server::encode_cellular_action_block(actions, batch.header.begin_tick, batch.header.end_tick); if (!previous || !predecessor_digest || !trace || !action_block || previous->profile != CheckpointProfile::cellular_lives_v1 || predecessor.head.digest != *predecessor_digest || previous->sequence != predecessor.head.sequence || previous->commit != predecessor.head.commit || previous->end_tick != predecessor.head.end_tick || batch.header.world != previous->key.world || batch.header.region != previous->key.region || batch.header.frame != previous->frame || batch.header.predecessor != previous->commit || batch.header.predecessor_digest != *predecessor_digest || batch.header.begin_tick != previous->end_tick || candidate.world() != previous->key.world || candidate.region() != previous->key.region || candidate.frame() != previous->frame || candidate.format_version() != previous->cellular_versions.envelope || candidate.rules_version() != previous->cellular_versions.rules || candidate.tick() != batch.header.end_tick) return std::unexpected{failure(PublicationError::candidate)}; auto predecessor_bytes = objects.get({previous->payload_sha256, previous->payload_bytes}); if (!predecessor_bytes) return std::unexpected{failure(PublicationError::predecessor, predecessor_bytes.error())}; auto base = restore_cellular_payload(*predecessor_bytes, *previous); if (!base) return std::unexpected{failure(PublicationError::predecessor)}; auto replay = server::replay_cellular_batch(**base, batch); const auto payload = candidate.snapshot(); if (!replay || (*replay)->snapshot() != payload || !server::match_cellular_actions_to_trace(**base, batch, actions)) return std::unexpected{failure(PublicationError::candidate)}; const auto payload_digest = sha256(payload); const auto trace_digest = sha256(*trace); if (!payload_digest || !trace_digest) return std::unexpected{failure(PublicationError::digest)}; auto manifest = successor_manifest(*previous, *predecessor_digest, commit, lease, batch.header.end_tick, build, payload.size(), *payload_digest, {trace->size(), *trace_digest, 0, {}}); auto manifest_bytes = manifest ? encode_manifest(*manifest) : std::expected, CheckpointError>{ std::unexpected{CheckpointError::format}}; if (!manifest || !manifest_bytes || !restore_cellular_payload(payload, *manifest)) return std::unexpected{failure(PublicationError::candidate)}; if (auto stored = put_verified(objects, payload, {*payload_digest, payload.size()}); !stored) return std::unexpected{stored.error()}; if (auto stored = put_verified(objects, *trace, {*trace_digest, trace->size()}); !stored) return std::unexpected{stored.error()}; CellularPreparedCommit prepared{previous->key, commit, *manifest_bytes, *trace, *action_block}; if (hooks.before_transaction) hooks.before_transaction(); auto committed = retry_cellular_prepared(db, prepared, timeout); if (!committed) return std::unexpected{committed.error()}; return PublishedCellularBatch{std::move(*committed)}; } std::expected recover_cellular_checkpoint(Postgres& db, const FilesystemObjectStore& objects, RegionKey key, const LeaseGrant& lease, std::span retained_builds, milliseconds timeout) { const auto fail_with = [](RecoveryError kind) { return std::unexpected{RecoveryFailure{kind, {}}}; }; auto committed = load_region_checkpoint(db, key, timeout); if (!committed) return std::unexpected{ RecoveryFailure{committed.error().kind == LeaseStoreError::not_provisioned ? RecoveryError::not_provisioned : RecoveryError::store, committed.error()}}; const auto digest = sha256(committed->manifest); auto manifest = decode_manifest(committed->manifest); if (!digest || *digest != committed->head.digest || !manifest || manifest->key != key || manifest->sequence != committed->head.sequence || manifest->commit != committed->head.commit || manifest->end_tick != committed->head.end_tick || manifest->frame != committed->head.frame) return fail_with(RecoveryError::manifest); if (!supported(*manifest) || manifest->profile != CheckpointProfile::cellular_lives_v1 || std::ranges::find(retained_builds, manifest->build) == retained_builds.end()) return fail_with(RecoveryError::unsupported); if (lease.frame != manifest->frame) return fail_with(RecoveryError::unsupported); auto payload = objects.get({manifest->payload_sha256, manifest->payload_bytes}); if (!payload) return fail_with(payload.error() == ObjectError::io ? RecoveryError::store : RecoveryError::corrupt_payload); auto state = restore_cellular_payload(*payload, *manifest); if (!state) return fail_with(RecoveryError::payload); std::vector actions; if (manifest->sequence != 0 && manifest->begin_tick == manifest->end_tick) { auto migration = load_cellular_profile_migration(db, key, lease, manifest->commit, timeout); if (!migration) return std::unexpected{RecoveryFailure{RecoveryError::store, migration.error()}}; if (!*migration || (*migration)->target_sequence != manifest->sequence || (*migration)->target_commit != manifest->commit || (*migration)->target_manifest_sha256 != *digest || (*migration)->target_payload_sha256 != manifest->payload_sha256 || (*migration)->target_sequence == 0) return fail_with(RecoveryError::history); auto predecessor = load_region_commit(db, key, manifest->sequence - 1, timeout); if (!predecessor) return std::unexpected{RecoveryFailure{RecoveryError::tail, predecessor.error()}}; const auto source_manifest_digest = sha256(predecessor->manifest); auto source_manifest = decode_manifest(predecessor->manifest); const auto source_manifest_bytes = encode_manifest(source_manifest ? *source_manifest : CheckpointManifest{}); const auto target_manifest_bytes = encode_manifest(*manifest); if (!source_manifest_digest || !source_manifest || !source_manifest_bytes || !target_manifest_bytes || *source_manifest_digest != manifest->predecessor_digest || predecessor->head.digest != *source_manifest_digest || predecessor->head.commit != manifest->predecessor_commit || predecessor->head.sequence != manifest->sequence - 1 || source_manifest->profile != CheckpointProfile::cellular_lives_v1 || (source_manifest->cellular_versions != cellular_v1_versions && source_manifest->cellular_versions != cellular_v2_versions) || ((source_manifest->cellular_versions == cellular_v1_versions) != (manifest->cellular_versions == cellular_v2_versions)) || source_manifest->end_tick != manifest->end_tick || (*migration)->source_sequence != source_manifest->sequence || (*migration)->source_commit != source_manifest->commit || (*migration)->source_manifest_sha256 != *source_manifest_digest || (*migration)->source_payload_sha256 != source_manifest->payload_sha256 || (*migration)->source_versions.size() != 36 || !std::ranges::equal((*migration)->source_versions, std::span{*source_manifest_bytes}.subspan(160, 36)) || (*migration)->target_versions.size() != 36 || !std::ranges::equal((*migration)->target_versions, std::span{*target_manifest_bytes}.subspan(160, 36))) return fail_with(RecoveryError::history); auto source_bytes = objects.get({source_manifest->payload_sha256, source_manifest->payload_bytes}); if (!source_bytes) return fail_with(source_bytes.error() == ObjectError::io ? RecoveryError::store : RecoveryError::tail); const auto source_payload_digest = sha256(*source_bytes); if (!source_payload_digest || *source_payload_digest != source_manifest->payload_sha256) return fail_with(RecoveryError::tail); auto source_state = restore_cellular_payload(*source_bytes, *source_manifest); if (!source_state || (*source_state)->format_version() != source_manifest->cellular_versions.envelope) return fail_with(RecoveryError::tail); auto migrated = source_manifest->cellular_versions == cellular_v1_versions ? (*source_state)->migrate_to_v2() : (*source_state)->migrate_to_v3(); if (!migrated || (*migrated)->tick() != manifest->end_tick || (*migrated)->snapshot() != *payload) return fail_with(RecoveryError::history); return RecoveredCellularCheckpoint{std::move(*committed), *manifest, std::move(*state), {}}; } if (manifest->sequence != 0) { auto action_bytes = load_cellular_publication_actions(db, key, lease, manifest->commit, timeout); if (!action_bytes) return std::unexpected{RecoveryFailure{RecoveryError::store, action_bytes.error()}}; if (!*action_bytes) return fail_with(RecoveryError::history); auto trace_bytes = objects.get({manifest->batch.trace_sha256, manifest->batch.trace_bytes}); if (!trace_bytes) return fail_with(trace_bytes.error() == ObjectError::io ? RecoveryError::store : RecoveryError::tail); auto trace = server::decode_cellular_batch(*trace_bytes); if (!trace) return fail_with(RecoveryError::tail); if (trace->header.world != key.world || trace->header.region != key.region || trace->header.frame != manifest->frame || trace->header.predecessor != manifest->predecessor_commit || trace->header.predecessor_digest != manifest->predecessor_digest || trace->header.begin_tick != manifest->begin_tick || trace->header.end_tick != manifest->end_tick) return fail_with(RecoveryError::tail); auto committed_births = load_cellular_publication_births(db, key, lease, manifest->commit, timeout); if (!committed_births) return std::unexpected{RecoveryFailure{RecoveryError::store, committed_births.error()}}; std::vector traced_births; for (std::size_t tick_index = 0; tick_index < trace->ticks.size(); ++tick_index) { for (const auto& birth : trace->ticks[tick_index].births) { traced_births.push_back({birth.account, manifest->commit, birth.request, birth.identity, manifest->begin_tick + tick_index + 1, manifest->sequence}); } } if (traced_births != *committed_births) return fail_with(RecoveryError::history); auto predecessor = load_region_commit(db, key, manifest->sequence - 1, timeout); if (!predecessor) return std::unexpected{RecoveryFailure{RecoveryError::tail, predecessor.error()}}; const auto predecessor_digest = sha256(predecessor->manifest); auto previous = decode_manifest(predecessor->manifest); if (!predecessor_digest || *predecessor_digest != manifest->predecessor_digest || predecessor->head.digest != manifest->predecessor_digest || predecessor->head.commit != manifest->predecessor_commit || predecessor->head.sequence != manifest->sequence - 1 || !previous || previous->profile != CheckpointProfile::cellular_lives_v1 || previous->end_tick != manifest->begin_tick) return fail_with(RecoveryError::tail); auto base_bytes = objects.get({previous->payload_sha256, previous->payload_bytes}); if (!base_bytes) return fail_with(base_bytes.error() == ObjectError::io ? RecoveryError::store : RecoveryError::tail); auto base = restore_cellular_payload(*base_bytes, *previous); if (!base) return fail_with(RecoveryError::tail); auto batch_actions = server::decode_cellular_action_block( **action_bytes, manifest->begin_tick, manifest->end_tick); if (!batch_actions || !server::match_cellular_actions_to_trace(**base, *trace, *batch_actions)) return fail_with(RecoveryError::history); auto replay = server::replay_cellular_batch(**base, *trace); if (!replay || (*replay)->snapshot() != *payload) return fail_with(RecoveryError::tail); std::vector refs; refs.reserve(batch_actions->size()); for (const auto& action : *batch_actions) refs.push_back({action.account, action.action_id}); auto records = find_region_action_records(db, key, lease, refs, timeout); if (!records) return std::unexpected{RecoveryFailure{RecoveryError::store, records.error()}}; for (std::size_t i = 0; i < batch_actions->size(); ++i) { if (!(*records)[i]) return fail_with(RecoveryError::history); const auto& record = *(*records)[i]; const auto& action = (*batch_actions)[i]; if (record.kind != 2 || record.result != 5 || !record.cellular_input || *record.cellular_input != std::vector(action.input.begin(), action.input.end()) || record.action.region != key.region || record.action.tick != input_tick(action) || record.action.commit_sequence != manifest->sequence) return fail_with(RecoveryError::history); } actions = std::move(*batch_actions); } return RecoveredCellularCheckpoint{std::move(*committed), *manifest, std::move(*state), std::move(actions)}; } } // namespace evo::persistence