#include "evo/world/transfers.hpp" #include #include #include #include #include #include #include namespace { using namespace evo::world; constexpr WorldIdentity id{7, 9}; constexpr std::array voxels{{{0, 0, -16000}, {1, 0, -16000}}}; void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("transfers line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) template bool refused(const std::expected& r, TransferError e) { return !r && r.error() == e; } struct Parts { std::unique_ptr fields; std::unique_ptr terrain; std::array accounts; }; Parts parts(bool loaded = true, bool all = true, std::size_t field_budget = 2000000) { const std::array sites{{{voxels[0], {{0}, {0}, {0}, {10}, {20}, {3}}, {1}}, {voxels[1], {{0}, {0}, {0}, {10}, {20}, {3}}, {1}}}}; const std::uint64_t stock = 10; std::array openings; for (std::size_t k = 0; k < field_count; ++k) openings[k] = {static_cast(k), {&stock, 1}}; const FieldDefaults defaults{{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{20}, evo::accounting::Femtograms{20}}}; auto f = FieldStore::create(id, 1, defaults, sites, std::span{openings}.first(all ? field_count : 1), field_budget); CHECK(f); auto t = ChunkStore::create({}, 2, 2000000, {{VolumeUnits{100}, VolumeUnits{100}}}); CHECK(t); if (loaded) CHECK((*t)->load({0, 0, -1000})); Parts p{std::move(*f), std::move(*t), {}}; for (std::size_t i = 0; i < 2; ++i) { p.accounts[i].id = {i + 1}; p.accounts[i].capacities.fill(100); } return p; } auto adopt(Parts p, std::size_t budget = 4000000, WorldIdentity identity = id) { return EnvironmentalTransfers::create(identity, std::move(p.fields), std::move(p.terrain), p.accounts, budget); } auto owner() { auto r = adopt(parts()); CHECK(r); return std::move(*r); } EnvironmentView view(const EnvironmentalTransfers& o, std::uint64_t tick = 1, std::uint32_t mask = 1023) { auto v = query_environment(o.fields(), o.terrain(), tick, voxels, mask); CHECK(v); return std::move(*v); } EnvironmentalLeg leg(Field f = Field::nitrogen, std::uint64_t amount = 10) { return {voxels[0], {1}, f, ResourceDirection::to_organism, amount}; } struct State { WorldBytes fields; std::vector accounts; auto operator<=>(const State&) const = default; }; State state(const EnvironmentalTransfers& o) { return {o.fields().snapshot(), {o.organisms().begin(), o.organisms().end()}}; } void atomicity() { auto o = owner(); auto v = view(*o); auto a = leg(); const auto total = o->totals(); const auto receipt = o->commit({1, 1, {&a, 1}}, v, 1); CHECK(receipt); const auto committed = state(*o); CHECK(o->organisms()[0].balances[1] == 10 && *o->fields().read(0, Field::nitrogen) == 0); CHECK(o->totals() == total); CHECK(o->commit({1, 1, {&a, 1}}, v, 999) == receipt); CHECK(state(*o) == committed); a.organism = {2}; CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::conflict)); CHECK(refused(o->commit({2, 1, {&a, 1}}, v, 1), TransferError::stale_view)); auto fresh = view(*o); CHECK(refused(o->commit({2, 1, {&a, 1}}, fresh, 1), TransferError::insufficient)); CHECK(state(*o) == committed); a = leg(Field::water, 3); std::array batch{a, leg(Field::nitrogen, 1)}; CHECK(refused(o->commit({2, 1, batch}, fresh, 1), TransferError::insufficient)); CHECK(state(*o) == committed); batch[1] = leg(Field::organic_other, 4); CHECK(o->commit({2, 1, batch}, fresh, 1)); CHECK(o->organisms()[0].balances[0] == 3 && o->organisms()[0].balances[6] == 4); CHECK(o->totals() == total); auto next = view(*o); for (auto& b : batch) b.direction = ResourceDirection::to_environment; CHECK(o->commit({3, 1, batch}, next, 1)); CHECK(o->organisms()[0].balances[0] == 0); CHECK(o->totals() == total); } void rejection() { auto o = owner(); auto v = view(*o); auto a = leg(); const auto before = state(*o); auto other = owner(); auto alien = view(*other); CHECK(refused(o->commit({1, 1, {&a, 1}}, alien, 1), TransferError::wrong_owner)); CHECK(refused(o->commit({1, 2, {&a, 1}}, v, 2), TransferError::stale_view)); CHECK(refused(o->commit({0, 1, {&a, 1}}, v, 1), TransferError::invalid_request)); CHECK(refused(o->commit({1, 1, {}}, v, 1), TransferError::invalid_request)); std::array many{}; CHECK(refused(o->commit({1, 1, many}, v, 1), TransferError::invalid_request)); a.organism = {3}; CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::unknown_organism)); a = leg(); a.voxel.x = 3; CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::uncovered)); a = leg(); auto limited = view(*o, 1, 1); CHECK(refused(o->commit({1, 1, {&a, 1}}, limited, 1), TransferError::uncovered)); a.amount = 0; CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::invalid_request)); CHECK(state(*o) == before); auto missing = adopt(parts(true, false)); CHECK(missing); auto mv = view(**missing); a = leg(); CHECK(refused((*missing)->commit({1, 1, {&a, 1}}, mv, 1), TransferError::missing)); auto p = parts(); p.accounts[0].capacities[1] = 1; auto small = adopt(std::move(p)); CHECK(small); auto sv = view(**small); CHECK(refused((*small)->commit({1, 1, {&a, 1}}, sv, 1), TransferError::capacity)); p = parts(); p.accounts[0].balances[0] = 20; auto water = adopt(std::move(p)); CHECK(water); auto wv = view(**water); a = leg(Field::water, 11); a.direction = ResourceDirection::to_environment; const auto wb = state(**water); CHECK(refused((*water)->commit({1, 1, {&a, 1}}, wv, 1), TransferError::capacity)); CHECK(state(**water) == wb); } void admission_budget() { CHECK(refused(adopt(parts(false)), TransferError::terrain_binding)); CHECK(refused(adopt(parts(), 4000000, {8, 9}), TransferError::identity)); auto p = parts(); p.accounts[1].id = {1}; CHECK(refused(adopt(std::move(p)), TransferError::config)); p = parts(); p.accounts[0].id = {0}; CHECK(refused(adopt(std::move(p)), TransferError::config)); p = parts(); p.accounts[0].balances[0] = 101; CHECK(refused(adopt(std::move(p)), TransferError::capacity)); p = parts(); p.accounts[0].balances[1] = std::numeric_limits::max(); p.accounts[0].capacities[1] = p.accounts[0].balances[1]; CHECK(refused(adopt(std::move(p)), TransferError::overflow)); auto o = owner(); const auto tight = o->accounted_bytes() + EnvironmentalTransfers::scratch_bytes; auto bounded = adopt(parts(), tight); CHECK(bounded); auto v = view(**bounded); auto a = leg(); const auto before = state(**bounded); CHECK(refused((*bounded)->commit({1, 1, {&a, 1}}, v, 1), TransferError::budget)); CHECK(state(**bounded) == before); p = parts(); const auto fb = p.fields->accounted_bytes() + FieldStore::scratch_bytes; bounded = adopt(parts(true, true, fb)); CHECK(bounded); 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(); for (std::uint64_t command = 1; command <= 100; ++command) { auto v = view(*o, command); std::array batch; for (std::size_t k = 0; k < field_count; ++k) { batch[k] = leg(static_cast(k), 1); if (command % 2 == 0) batch[k].direction = ResourceDirection::to_environment; } auto r = o->commit({command, command, batch}, v, command); CHECK(r); CHECK(o->totals() == total); for (std::size_t k = 0; k < field_count; ++k) { CHECK(o->organisms()[0].balances[k] == command % 2); CHECK(*o->fields().read(0, static_cast(k)) == 10 - command % 2); } CHECK(o->commit({command, command, batch}, v, command + 1) == r); batch[0].amount = 2; CHECK(refused(o->commit({command, command, batch}, v, command), TransferError::conflict)); } auto v = view(*o, 101); auto a = leg(Field::water, 1); CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 101), TransferError::stale_command)); CHECK(o->commit({std::numeric_limits::max(), 101, {&a, 1}}, v, 101)); CHECK(o->commit({std::numeric_limits::max(), 101, {&a, 1}}, v, 102)); } } // namespace int main() { try { codec(); atomicity(); rejection(); admission_budget(); conservation_history(); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } catch (...) { return 1; } }