diff --git a/CMakeLists.txt b/CMakeLists.txt index d2e2103..7c3b610 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ target_include_directories(evo_simulation PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/in target_compile_features(evo_simulation PUBLIC cxx_std_23) evo_owned_target(evo_simulation) -set(evo_world_sources src/world/coordinates.cpp src/world/generation.cpp src/world/chunks.cpp src/world/edits.cpp src/world/codec.cpp src/world/local_files.cpp src/world/environment_units.cpp src/world/fields.cpp src/world/environment.cpp src/world/transfers.cpp) +set(evo_world_sources src/world/coordinates.cpp src/world/generation.cpp src/world/chunks.cpp src/world/edits.cpp src/world/codec.cpp src/world/local_files.cpp src/world/environment_units.cpp src/world/fields.cpp src/world/environment.cpp src/world/transfers.cpp src/world/transfer_codec.cpp) add_library(evo_world STATIC ${evo_world_sources}) add_library(evo::world ALIAS evo_world) target_include_directories(evo_world PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 04b42c4..8598a06 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -440,3 +440,8 @@ M6.5 sequencing review: [ADR-0054](adr/0054-m65-source-persistence-prerequisite. is proposed because ADR-0051 requires persistence before rates while ADR-0053 defers coupled persistence to M6.8. Its recommended prerequisite and task breakdown are pending scope confirmation; the M6.5 completion criteria above remain unchanged. + +Accepted 2026-09-27: ADR-0054 brings coupled snapshot/restore into M6.5. M6.5a's +resource codec is implemented; the earlier pending-scope statement is superseded. +Next are 6.5b conversions, 6.5c complete rate/biology persistence and fixture, and +6.5d qualification. M6.8 retains the full decomposition/regrowth ecology gate. diff --git a/docs/STATUS.md b/docs/STATUS.md index 916c3a6..8354c55 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -663,3 +663,17 @@ minimal coupled buffer codec forward, preserving the earlier guarantee. The prop breaks M6.5 into codec, explicit biological conversion contract, rate-driven fixture, and qualification segments. No source-rate code or public interface changed in this review; M6.5 remains incomplete. M6.4's validated behavior is unchanged. + +## Accepted M6.5 sequencing and M6.5a codec (2026-09-27) + +The maintainer accepted ADR-0054: bring coupled snapshot/restore forward. This +supersedes the pending-decision status above. M6.5a now implements +[resource snapshot v1](../schemas/coupled-resources.md): terrain, finite fields, +organism accounts/capacities, adoption watermark and chronological full retry history +restore as one validated owner. Restore audits retained transfers backwards against +current balances and validates nested codecs and aggregate ownership/budgets. + +Next: M6.5b explicit capture/growth/feeding conversion contract, followed by M6.5c's +complete source-rate/biology envelope and M6.5d qualification. No rates are enabled +by the resource codec; no source progress is invented during restore. M6.5 as a +whole remains incomplete. Durable publication and region recovery remain M7. diff --git a/docs/adr/0053-atomic-environmental-transfers.md b/docs/adr/0053-atomic-environmental-transfers.md index 8c746f5..f9cd12e 100644 --- a/docs/adr/0053-atomic-environmental-transfers.md +++ b/docs/adr/0053-atomic-environmental-transfers.md @@ -75,3 +75,7 @@ Test last-nutrient contention, exact/changed/expired retries, stale/foreign view uncovered endpoints, capacity, overflow, peak budgets, late-leg rollback and independent per-channel conservation. No account may progress offline via this primitive: biology adapters must validate active lifecycle and permitted actions before submission. + +M6.5 amendment (2026-09-27): accepted ADR-0054 brings the coupled buffer codec +forward to M6.5a. This supersedes the deferral above; rate/biology progress must +join the aggregate before rate-driven execution in M6.5c. Durable publication stays M7. diff --git a/docs/adr/0054-m65-source-persistence-prerequisite.md b/docs/adr/0054-m65-source-persistence-prerequisite.md index 5e95f71..b08efff 100644 --- a/docs/adr/0054-m65-source-persistence-prerequisite.md +++ b/docs/adr/0054-m65-source-persistence-prerequisite.md @@ -1,9 +1,8 @@ # ADR-0054: M6.5 source persistence prerequisite ## Status -Proposed, 2026-09-27. No rate-driven implementation is authorized by this proposal. -M6.4 remains complete as a scoped in-memory transfer primitive. M6.5 is pending -resolution of the prerequisite below, not complete. +Accepted by the maintainer, 2026-09-27. Bring coupled snapshot/restore into M6.5. +M6.4 remains complete as a scoped in-memory transfer primitive. M6.5 follows the segments below and is not yet complete. ## Context The accepted contracts disagree about when coupled persistence is required: @@ -29,7 +28,7 @@ The repository working agreement requires stopping affected implementation and proposing a resolution when architecture conflicts. This record exposes the mismatch rather than silently interpreting the later scope statement as superseding ADR-0051. -## Decision (recommended, pending scope confirmation) +## Decision Bring the minimal coupled binary-buffer snapshot/restore contract forward into the M6.5 prerequisite. Keep durable filesystem publication and region crash recovery in M7; a canonical buffer codec is not a durable acknowledgment or fencing mechanism. @@ -99,6 +98,6 @@ Buffer round trips do not prove disk crash consistency, host-loss safety or regi ownership. Keep those delivery gates separate and unclaimed. ## Consequences -After acceptance, revise the scoped ADR and roadmap references together before code. -Until then, do not enable rate integration, weaken persistence requirements, or report +Acceptance brings the minimal coupled codec forward; revise scoped references together. +Until complete rate/biology state is serialized, do not enable rate integration or report M6.5 as implemented. Existing tests and deployed behavior remain unchanged. diff --git a/docs/adr/README.md b/docs/adr/README.md index f42ad67..35362a4 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -60,4 +60,4 @@ design. No unadopted candidate is a link dependency of the proof. - [ADR-0051: Optional environmental fields](0051-optional-environmental-fields.md) - accepted for M6.2 finite sparse pages, local transfers and field snapshot v1. - [ADR-0052: Environment views](0052-read-only-environment-views.md) - accepted for M6.3 bounded read-only footprint queries and freshness validation. - [ADR-0053: Atomic environmental transfers](0053-atomic-environmental-transfers.md) - accepted for M6.4 tagged resource ownership, atomic local batches and bounded exact retries. -- [ADR-0054: M6.5 source persistence prerequisite](0054-m65-source-persistence-prerequisite.md) - proposed resolution of rate-persistence versus M6.8 sequencing; not implemented. +- [ADR-0054: M6.5 source persistence prerequisite](0054-m65-source-persistence-prerequisite.md) - accepted: coupled codec brought forward into M6.5; M6.5a implemented, rate/biology envelope follows. diff --git a/docs/architecture/WORLD_ARCHITECTURE.md b/docs/architecture/WORLD_ARCHITECTURE.md index b4f788f..4ab0878 100644 --- a/docs/architecture/WORLD_ARCHITECTURE.md +++ b/docs/architecture/WORLD_ARCHITECTURE.md @@ -192,3 +192,8 @@ stocks, terrain binding and tagged organism resource accounts. Fresh views autho only staged transfers; both endpoints and the retry receipt publish together after validation and allocation. Accounts are resource endpoints; biological lifecycle integration follows in M6.5. Field-only snapshots cannot recover a coupled owner. + +M6.5a now provides [coupled resource snapshots](../../schemas/coupled-resources.md) +under accepted ADR-0054. This is a detached, bounded buffer codec; M7 still owns +file publication and durable acknowledgment. M6.5c must extend persistence to +source-rate and biological progress before enabling the corresponding simulation. diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 7f0ac36..a6be337 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -1800,3 +1800,28 @@ ADRs 0050/0051 and 0053. ADR-0054 proposes a resolution; it is not accepted or implemented. `git diff --check` passed. No source, public API, test, schema or build configuration changed, so builds/sanitizers were not rerun for this proposal. The M6.4 validation above remains historical evidence, not M6.5 completion evidence. + +## M6.5a coupled resource codec - 2026-09-27 + +ADR-0054 accepted by the maintainer. Added resource envelope v1 without changing +nested terrain/field formats or existing simulation goldens. Rates are still disabled; +source configuration/residuals and biology join the later M6.5c fixture envelope. + +Executed Windows checks: + +- Release check: 52/52 CTests passed with NDEBUG. +- Analysis check: clang-tidy/warnings-as-errors build and 52/52 CTests passed. +- ASan check: 52/52 CTests passed. +- After tightening restore to require all mapped chunks already in the snapshot, + Release and analysis rebuilt and environment-transfers-contracts passed again; + the ASan full run includes this final adjustment. +- Release format target passed. + +Codec tests cover empty history, 66 transfers crossing the retry-ring boundary, +canonical restored bytes, exact/conflicting/expired retries, equivalent continuation, +all truncation lengths, checksum errors, recomputed-checksum invalid version/counts/ +amounts, identity mismatch and each budget. Initial compilation caught missing codec +error enum entries; corrected before the passing runs above. + +No Linux/UBSan/TSan, disk crash, allocation-failure injection or cluster validation +was performed locally. Buffer round trips are not durable publication. M6.5b-d remain. diff --git a/docs/world/ENVIRONMENTAL_TRANSFERS.md b/docs/world/ENVIRONMENTAL_TRANSFERS.md index f9fc8b8..f688a2f 100644 --- a/docs/world/ENVIRONMENTAL_TRANSFERS.md +++ b/docs/world/ENVIRONMENTAL_TRANSFERS.md @@ -83,3 +83,8 @@ coupled world state. Tests exercise in-memory atomicity, not crash recovery. M6.5 biology adapters must validate active/alive status, capabilities, source budgets and biological costs. This resource endpoint abstraction neither implements metabolism nor allows offline progression. Next: one producer/consumer fixture using this owner. + +M6.5a amendment: accepted ADR-0054 brings a [coupled buffer codec](../../schemas/coupled-resources.md) +forward. `snapshot`/`restore` now save terrain, fields, accounts and full retry history +together. This supersedes the M6.8 resource-codec deferral above. No rate/biology +state exists yet; the later fixture must include it before enabling source integration. diff --git a/include/evo/world/transfers.hpp b/include/evo/world/transfers.hpp index ec6fdfd..ef91a78 100644 --- a/include/evo/world/transfers.hpp +++ b/include/evo/world/transfers.hpp @@ -52,7 +52,10 @@ enum class TransferError : std::uint8_t { unknown_organism, insufficient, conflict, - stale_command + stale_command, + format, + version, + checksum }; class EnvironmentalTransfers { public: @@ -76,6 +79,11 @@ class EnvironmentalTransfers { [[nodiscard]] std::span organisms() const noexcept { return std::span{organisms_}.first(count_); } + static constexpr std::size_t max_snapshot_bytes = std::size_t{72} * 1024 * 1024; + [[nodiscard]] std::expected snapshot() const; + [[nodiscard]] static std::expected, TransferError> + restore(std::span bytes, WorldIdentity identity, std::size_t byte_budget, + std::size_t field_budget, std::size_t terrain_budget); [[nodiscard]] accounting::Inventory totals() const noexcept; [[nodiscard]] std::size_t accounted_bytes() const noexcept; [[nodiscard]] std::expected @@ -93,5 +101,6 @@ class EnvironmentalTransfers { std::array organisms_{}; std::array history_{}; std::size_t count_{}, budget_{}, next_history_{}; + std::uint64_t adoption_command_{}; }; } // namespace evo::world diff --git a/schemas/coupled-resources.md b/schemas/coupled-resources.md new file mode 100644 index 0000000..07a91ed --- /dev/null +++ b/schemas/coupled-resources.md @@ -0,0 +1,35 @@ +# Coupled resource snapshot v1 (M6.5a) + +Little endian, bounded to 72 MiB, corruption checksum FNV-1a-64 (not authentication). +No native layouts or pointers. Nested terrain and field codecs retain their versions. +This format has no source rates or biological process state: it must not be used to +resume a rate-enabled fixture. M6.5c requires a new complete fixture envelope. + +Header: magic u64 0x31504c43564f4541, format u32=1, total length u32, +world u64, frame u64, adoption command watermark u64, account count u32, +history count u32, terrain payload length u32, field payload length u32. +Then terrain bytes, field bytes, accounts and chronological retained history; +finally checksum u64 over all preceding bytes. +Account: ID u64, ten u64 balances, ten u64 capacities (Field order). +History: command u64, tick u64, leg count u32; each leg is voxel x/y/z i64 +(two's complement), organism ID u64, field u8, direction u8, amount u64. +No ring position or unused entries are serialized. Restore packs history in order. + +Require 1..64 sorted unique accounts, 0..64 histories, 1..32 legs per history. +Commands strictly increase above adoption watermark; last equals the field command +(or adoption equals field command if empty). Validate every endpoint/tag/amount. +Reverse the retained legs from current stocks to verify supplies and capacities of +each prior state. This establishes plausible retained transfers, not authentic history. +Revalidate field/terrain identity and mapped substrate; all mapped chunks must be +present in the nested terrain snapshot. Query tokens never survive restore. + +Restore receives total-owner, field and terrain budgets. Charge owner/scratch first, +then fields, then terrain under remaining total allowance. Input/output buffers and nested codec decode scratch +follow the existing codec exclusions; fixed reverse-audit scratch is bounded to 32KiB +and runs separately from transfer staging. Allocation failures propagate before any +returned owner. Failure leaves the caller's existing owner untouched. + +Snapshot/restore are pure buffer operations with exclusive host access. They do not +publish files, fence duplicate processes or acknowledge durability. Tests must cover +canonical bytes, exact/changed retries after restore, continuation, ring wrap, +truncation/corruption, recomputed-checksum malformed state, identity and budgets. diff --git a/src/world/transfer_codec.cpp b/src/world/transfer_codec.cpp new file mode 100644 index 0000000..0404ff6 --- /dev/null +++ b/src/world/transfer_codec.cpp @@ -0,0 +1,221 @@ +#include "evo/world/transfers.hpp" +#include +#include +#include +namespace evo::world { +namespace { +constexpr std::uint64_t magic = 0x31504c43564f4541ULL; +void put(WorldBytes& b, std::uint64_t v, unsigned n) { + for (unsigned i = 0; i < n; ++i) { + b.push_back(static_cast(v & 255U)); + v >>= 8U; + } +} +std::uint64_t hash(std::span b) { + std::uint64_t h = 14695981039346656037ULL; + for (auto v : b) + h = (h ^ v) * 1099511628211ULL; + return h; +} +struct Reader { + std::span bytes; + std::size_t at{}; + bool ok{true}; + std::uint64_t get(unsigned n) { + if (n > bytes.size() - at) { + ok = false; + return 0; + } + std::uint64_t v{}; + for (unsigned i = 0; i < n; ++i) + v |= std::uint64_t{bytes[at++]} << (8U * i); + return v; + } + auto take(std::size_t n) { + if (n > bytes.size() - at) { + ok = false; + return std::span{}; + } + auto s = bytes.subspan(at, n); + at += n; + return s; + } +}; +} // namespace +std::expected EnvironmentalTransfers::snapshot() const { + auto terrain = terrain_->snapshot(fields_->identity()); + if (!terrain) + return std::unexpected{TransferError::format}; + const auto fields = fields_->snapshot(); + std::array ordered{}; + std::size_t count{}; + for (const auto& h : history_) + if (h.receipt.command != 0) + ordered[count++] = &h; + std::sort(ordered.begin(), ordered.begin() + static_cast(count), + [](const auto* a, const auto* b) { return a->receipt.command < b->receipt.command; }); + std::size_t length = 64 + terrain->size() + fields.size() + count_ * 168; + for (std::size_t i = 0; i < count; ++i) + length += 20 + 42 * ordered[i]->receipt.legs; + if (length > max_snapshot_bytes) + return std::unexpected{TransferError::budget}; + WorldBytes out; + out.reserve(length); + put(out, magic, 8); + put(out, 1, 4); + put(out, length, 4); + put(out, fields_->identity().world, 8); + put(out, fields_->identity().frame, 8); + put(out, adoption_command_, 8); + put(out, count_, 4); + put(out, count, 4); + put(out, terrain->size(), 4); + put(out, fields.size(), 4); + out.insert(out.end(), terrain->begin(), terrain->end()); + out.insert(out.end(), fields.begin(), fields.end()); + for (const auto& a : organisms()) { + put(out, a.id.value, 8); + for (auto v : a.balances) + put(out, v, 8); + for (auto v : a.capacities) + put(out, v, 8); + } + for (std::size_t i = 0; i < count; ++i) { + const auto& h = *ordered[i]; + put(out, h.receipt.command, 8); + put(out, h.receipt.tick, 8); + put(out, h.receipt.legs, 4); + for (const auto& l : std::span{h.legs}.first(h.receipt.legs)) { + put(out, std::bit_cast(l.voxel.x), 8); + put(out, std::bit_cast(l.voxel.y), 8); + put(out, std::bit_cast(l.voxel.z), 8); + put(out, l.organism.value, 8); + put(out, static_cast(l.field), 1); + put(out, static_cast(l.direction), 1); + put(out, l.amount, 8); + } + } + put(out, hash(out), 8); + return out; +} +std::expected, TransferError> +EnvironmentalTransfers::restore(std::span bytes, WorldIdentity identity, + std::size_t budget, std::size_t field_budget, + std::size_t terrain_budget) { + if (bytes.size() < 64 || bytes.size() > max_snapshot_bytes) + return std::unexpected{TransferError::format}; + Reader r{bytes.first(bytes.size() - 8)}, tail{bytes.last(8)}; + if (r.get(8) != magic) + return std::unexpected{TransferError::format}; + if (r.get(4) != 1) + return std::unexpected{TransferError::version}; + if (r.get(4) != bytes.size()) + return std::unexpected{TransferError::format}; + if (hash(r.bytes) != tail.get(8)) + return std::unexpected{TransferError::checksum}; + if (WorldIdentity{r.get(8), r.get(8)} != identity || identity.world == 0 || identity.frame == 0) + return std::unexpected{TransferError::identity}; + const auto adoption = r.get(8), count = r.get(4), records = r.get(4), terrain_length = r.get(4), + field_length = r.get(4); + if (count == 0 || count > max_organisms || records > retained_commands || + terrain_length > max_world_snapshot_bytes || field_length > FieldStore::max_snapshot_bytes) + return std::unexpected{TransferError::format}; + const auto terrain_bytes = r.take(static_cast(terrain_length)); + const auto field_bytes = r.take(static_cast(field_length)); + if (!r.ok || count * 168 + records * 62 > r.bytes.size() - r.at) + return std::unexpected{TransferError::format}; + if (budget < sizeof(EnvironmentalTransfers) + scratch_bytes) + return std::unexpected{TransferError::budget}; + const auto available = budget - sizeof(EnvironmentalTransfers) - scratch_bytes; + auto fields = FieldStore::restore(field_bytes, identity, std::min(field_budget, available)); + if (!fields) + return std::unexpected{fields.error() == FieldError::budget ? TransferError::budget + : TransferError::format}; + if ((*fields)->sites().size() > max_sites) + return std::unexpected{TransferError::config}; + auto terrain = + ChunkStore::restore(terrain_bytes, identity, + std::min(terrain_budget, available - (*fields)->accounted_bytes())); + if (!terrain) + return std::unexpected{terrain.error() == WorldCodecError::budget ? TransferError::budget + : TransferError::format}; + + std::array accounts{}; + for (auto& a : std::span{accounts}.first(static_cast(count))) { + a.id = {r.get(8)}; + for (auto& v : a.balances) + v = r.get(8); + for (auto& v : a.capacities) + v = r.get(8); + } + auto out = create(identity, std::move(*fields), std::move(*terrain), + std::span{accounts}.first(static_cast(count)), budget); + if (!out) + return out; + auto& o = **out; + o.adoption_command_ = adoption; + std::uint64_t previous = adoption; + for (std::size_t i = 0; i < records; ++i) { + auto& h = o.history_[i]; + h.receipt = {r.get(8), r.get(8), static_cast(r.get(4))}; + if (!r.ok || h.receipt.command <= previous || h.receipt.legs == 0 || + h.receipt.legs > max_legs) + return std::unexpected{TransferError::format}; + previous = h.receipt.command; + for (auto& l : std::span{h.legs}.first(h.receipt.legs)) { + l.voxel = {std::bit_cast(r.get(8)), std::bit_cast(r.get(8)), + std::bit_cast(r.get(8))}; + l.organism = {r.get(8)}; + const auto field = r.get(1), direction = r.get(1); + l.amount = r.get(8); + if (!r.ok || field >= field_count || direction > 1 || l.amount == 0) + return std::unexpected{TransferError::format}; + l.field = static_cast(field); + l.direction = static_cast(direction); + } + } + if (!r.ok || r.at != r.bytes.size() || previous != o.fields_->last_command()) + return std::unexpected{TransferError::format}; + // Reverse retained history against current state: every predecessor must be possible. + std::array, field_count> values{}; + const auto sites = o.fields_->sites(); + for (std::size_t k = 0; k < field_count; ++k) + for (std::size_t j = 0; j < sites.size(); ++j) { + auto v = o.fields_->read(j, static_cast(k)); + if (v) + values[k][j] = *v; + } + for (std::size_t n = static_cast(records); n > 0; --n) { + const auto& h = o.history_[n - 1]; + for (std::size_t m = h.receipt.legs; m > 0; --m) { + const auto& l = h.legs[m - 1]; + const auto site = + std::lower_bound(sites.begin(), sites.end(), l.voxel, + [](const FieldSite& s, VoxelAddress v) { return s.voxel < v; }); + const auto end = accounts.begin() + static_cast(count); + const auto a = std::lower_bound( + accounts.begin(), end, l.organism, + [](const OrganismResources& x, OrganismResourceId v) { return x.id < v; }); + if (site == sites.end() || site->voxel != l.voxel || a == end || a->id != l.organism) + return std::unexpected{TransferError::format}; + const auto j = static_cast(site - sites.begin()), + k = static_cast(l.field); + if (!o.fields_->read(j, l.field)) + return std::unexpected{TransferError::format}; + const bool uptake = l.direction == ResourceDirection::to_organism; + auto& source = uptake ? a->balances[k] : values[k][j]; + auto& destination = uptake ? values[k][j] : a->balances[k]; + const auto cap = + uptake ? (l.field == Field::water ? o.fields_->water_capacity(j)->value + : std::numeric_limits::max()) + : a->capacities[k]; + if (source < l.amount || l.amount > cap - destination) + return std::unexpected{TransferError::format}; + source -= l.amount; + destination += l.amount; + } + } + o.next_history_ = static_cast(records) % retained_commands; + return out; +} +} // namespace evo::world diff --git a/src/world/transfers.cpp b/src/world/transfers.cpp index aae879d..fb973ea 100644 --- a/src/world/transfers.cpp +++ b/src/world/transfers.cpp @@ -58,6 +58,7 @@ EnvironmentalTransfers::create(WorldIdentity identity, std::unique_ptr(new EnvironmentalTransfers); + owner->adoption_command_ = fields->last_command(); owner->fields_ = std::move(fields); owner->terrain_ = std::move(terrain); std::copy(organisms.begin(), organisms.end(), owner->organisms_.begin()); diff --git a/tests/environment_transfers_tests.cpp b/tests/environment_transfers_tests.cpp index d7f753e..9f8406b 100644 --- a/tests/environment_transfers_tests.cpp +++ b/tests/environment_transfers_tests.cpp @@ -183,6 +183,69 @@ void admission_budget() { v = view(**bounded); CHECK(refused((*bounded)->commit({1, 1, {&a, 1}}, v, 1), TransferError::budget)); } +void codec() { + auto o = owner(); + for (std::uint64_t c = 1; c <= 66; ++c) { + auto v = view(*o, c); + auto a = leg(Field::water, 1); + if (c % 2 == 0) + a.direction = ResourceDirection::to_environment; + CHECK(o->commit({c, c, {&a, 1}}, v, c)); + } + auto saved = o->snapshot(); + CHECK(saved); + auto restored = EnvironmentalTransfers::restore(*saved, id, 4000000, 2000000, 2000000); + CHECK(restored); + CHECK((*restored)->snapshot() == saved); + CHECK(state(**restored) == state(*o)); + auto v = view(**restored, 67); + auto a = leg(Field::water, 1); + a.direction = ResourceDirection::to_environment; + CHECK((*restored)->commit({66, 66, {&a, 1}}, v, 67)); + a.amount = 2; + CHECK(refused((*restored)->commit({66, 66, {&a, 1}}, v, 67), TransferError::conflict)); + CHECK(refused((*restored)->commit({1, 1, {&a, 1}}, v, 67), TransferError::stale_command)); + a = leg(Field::nitrogen, 2); + auto original_view = view(*o, 67); + CHECK(o->commit({67, 67, {&a, 1}}, original_view, 67)); + CHECK((*restored)->commit({67, 67, {&a, 1}}, v, 67)); + CHECK(o->snapshot() == (*restored)->snapshot()); + CHECK(refused(EnvironmentalTransfers::restore(*saved, {8, 9}, 4000000, 2000000, 2000000), + TransferError::identity)); + CHECK(refused(EnvironmentalTransfers::restore(*saved, id, 1, 2000000, 2000000), + TransferError::budget)); + CHECK(refused(EnvironmentalTransfers::restore(*saved, id, 4000000, 1, 2000000), + TransferError::budget)); + CHECK(refused(EnvironmentalTransfers::restore(*saved, id, 4000000, 2000000, 1), + TransferError::budget)); + auto empty = owner(); + auto initial = empty->snapshot(); + CHECK(initial); + auto fresh = EnvironmentalTransfers::restore(*initial, id, 4000000, 2000000, 2000000); + CHECK(fresh); + CHECK((*fresh)->snapshot() == initial); + for (std::size_t n = 0; n < saved->size(); ++n) + CHECK(!EnvironmentalTransfers::restore(std::span{*saved}.first(n), id, 4000000, 2000000, + 2000000)); + auto bad = *saved; + bad[60] ^= 1; + CHECK(refused(EnvironmentalTransfers::restore(bad, id, 4000000, 2000000, 2000000), + TransferError::checksum)); + auto fix_hash = [](WorldBytes& bytes) { + std::uint64_t h = 14695981039346656037ULL; + for (auto b : std::span{bytes}.first(bytes.size() - 8)) + h = (h ^ b) * 1099511628211ULL; + for (unsigned i = 0; i < 8; ++i) + bytes[bytes.size() - 8 + i] = static_cast((h >> (8U * i)) & 255U); + }; + for (auto offset : {std::size_t{8}, std::size_t{40}, std::size_t{44}, saved->size() - 9}) { + bad = *saved; + bad[offset] = 255; + fix_hash(bad); + CHECK(!EnvironmentalTransfers::restore(bad, id, 4000000, 2000000, 2000000)); + } + CHECK((*restored)->snapshot() == o->snapshot()); +} void conservation_history() { auto o = owner(); const auto total = o->totals(); @@ -214,6 +277,7 @@ void conservation_history() { } // namespace int main() { try { + codec(); atomicity(); rejection(); admission_budget();