LPK/decision
7
0
Fork 0
forked from yvv/decision
Code Pull Requests Activity

WIP lot V : le tampon câblé dans le serveur (migration 0010, simulation, discard-simulation), tests en cours de reprise — repris tel quel après la coupure du 02/11

Browse Source 
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Yvv
2026-11-03 05:22:24 +01:00
co-authored by Claude Opus 5.5
parent ee37c3b4d5
commit 4b81a2e909
16 changed files with 1503 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ld-server/src/adoption.rs
+6 -1
View File
@@ -192,15 +192,20 @@ pub async fn run(state: &AppState, doc_id: &str) -> AppResult<Vec<Entered>> {
/// What an adoption keeps of the formula it was judged by. The four letters
/// stay where the rows of before have them (`majority_pct`, `gradient`, `base`,
/// `constant`: read as they were written); the level and the scale join them.
/// `constant`: read as they were written); the level and the scale join them —
/// and, for the act that ends the simulation (ADR 0012, `simulation::discard`),
/// the simulated share of the votes it entered with, the version it displaced
/// and the level of inertia of before.
fn kept_params(st: &DocState, unit: &docs::UnitRow, p: &docs::ProposalRow) -> serde_json::Value {
let level = st.voting_level(unit, p);
let f = st.scale().params(level);
let simulated = st.simulated_counted(&p.id);
serde_json::json!({
"majority_pct": f.majority_pct, "gradient": f.gradient, "base": f.base, "constant": f.constant,
"level": level, "share_pct": level.share_pct(),
"participation": st.participation.ratio, "participation_source": st.participation.source,
"participation_sample": st.participation.sample, "participation_median": st.participation.median,
"simulated": simulated, "displaced": unit.in_force_id, "from_inertia": docs::inertia_of(unit),
})
}
crates/ld-server/src/ballots.rs
+534 -123
View File
@@ -21,6 +21,21 @@
//! Ğecko code). A ballot is read one last time at its end (24 hours), then let
//! go; the adoption pass runs after each confirmation. Ballots let go are purged
//! after a while (a day for those the wallet never signed, a week for the others).
//!
//! **The buffer** (ADR 0012, Yvv 2026-11-02: « je vois ce que j'ai fait sans
//! attendre », with a control « a posteriori » of the integrity of the vote): a
//! pending ballot is an **intention**, seen at once by the person (« ton vote »)
//! and in the totals shown, never counted for adoption; the chain brings its
//! **proof**; the **reconciliation** (`ld_engine::buffer::reconcile`) keeps one
//! voice per identity and per version, the last in the order of the chain, and
//! sets aside what is never proven in time, refused, overtaken — or a *for*
//! proven while an objection holds its version back. What is set aside is told
//! in the box « Messages ».
//!
//! **The simulation**: while the chain is closed (no `LD_VOTE_ACCOUNT`), a group
//! of the chain votes anyway, without a wallet — through the same buffer: a
//! sealed ballot, simulated, proven at once by the simulated confirmer, for the
//! identity of the session.
use crate::AppState;
use crate::adoption::{self, Entered};
@@ -28,6 +43,7 @@ use crate::auth::{IdentityRow, User};
use crate::docs::{self, DocState};
use crate::error::{AppError, AppResult};
use crate::indexer::{self, Found, Reading};
use crate::messages::{self, Topic};
use crate::util;
use axum::Json;
use axum::extract::{Path, State};
@@ -35,10 +51,13 @@ use axum::http::{HeaderValue, header};
use axum::response::{IntoResponse, Response};
use ld_engine::address;
use ld_engine::ballot::{self, ChainPosition, Choice, Expected, Verdict};
use ld_engine::buffer::{self, Outcome, Proven, Stage};
use rand::RngCore;
use serde::Deserialize;
use serde_json::json;
use sqlx::SqliteConnection;
use std::collections::{HashMap, HashSet};
use std::sync::atomic::Ordering;
use std::time::Duration;
use tokio::sync::Mutex;
use trustin_access::VoteWay;
@@ -167,7 +186,62 @@ pub(crate) async fn write_server_votes(state: &AppState, identity: &str, casts:
Ok(())
}
/// `POST /api/docs/{id}/votes` — a grouped vote in a managed group: one write.
/// How a vote of this session is written by the server in a group now.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ServerWay {
/// A managed group: the server is the authority, the vote is recorded at once.
Direct,
/// A group of the chain while the chain is closed: a simulated ballot, proven
/// by the simulated confirmer (ADR 0012).
Simulated,
}
/// Where the vote goes through the chain and the chain is open, never on the
/// server (`409 chain_only`): a ballot to sign.
pub(crate) fn server_way(state: &AppState, group: &docs::GroupRow) -> AppResult<ServerWay> {
match trustin_access::vote_way(&group.to_group()) {
VoteWay::Server => Ok(ServerWay::Direct),
VoteWay::Chain if state.chain().is_some() => Err(AppError::Conflict("chain_only")),
VoteWay::Chain => Ok(ServerWay::Simulated),
}
}
/// May this session write its vote on the server, this way? trustinWallet's rules:
/// `votes_in` (a managed group), `casts_simulated` (the simulation).
pub(crate) async fn may_write(
state: &AppState,
user: &IdentityRow,
group: &docs::GroupRow,
way: ServerWay,
) -> AppResult<bool> {
let granted = docs::granted(state, &group.slug, &user.id).await?;
let (id, g) = (user.to_identity(), group.to_group());
Ok(match way {
ServerWay::Direct => trustin_access::votes_in(&id, &g, granted),
ServerWay::Simulated => trustin_access::casts_simulated(&id, &g, granted, state.chain().is_some()),
})
}
/// Writes the votes of a session on the server — directly, or in simulation — and
/// runs the adoption pass. Returns what entered into force.
pub(crate) async fn write(
state: &AppState,
user: &IdentityRow,
st: &DocState,
way: ServerWay,
casts: &[Cast],
) -> AppResult<Vec<Entered>> {
match way {
ServerWay::Direct => {
write_server_votes(state, &user.id, casts).await?;
adoption::run(state, &st.doc.id).await
}
ServerWay::Simulated => simulate(state, &user.id, st, casts).await,
}
}
/// `POST /api/docs/{id}/votes` — a grouped vote written by the server: one write
/// in a managed group, one simulated ballot while the chain is closed.
pub async fn vote_many(
State(state): State<AppState>,
User(user): User,
@@ -176,16 +250,84 @@ pub async fn vote_many(
) -> AppResult<Json<serde_json::Value>> {
let st = docs::load_state(&state, &doc_id).await?;
docs::require_open(&state, &user, &st.group).await?;
if trustin_access::vote_way(&st.group.to_group()) == VoteWay::Chain {
return Err(AppError::Conflict("chain_only"));
}
if !docs::may_vote(&state, &user, &st.group).await? {
let way = server_way(&state, &st.group)?;
if !may_write(&state, &user, &st.group, way).await? {
return Err(AppError::Forbidden);
}
let casts = casts(&st, &b.lines)?;
write_server_votes(&state, &user.id, &casts).await?;
let entered = adoption::run(&state, &st.doc.id).await?;
Ok(Json(json!({ "count": casts.len(), "entered": entered })))
let entered = write(&state, &user, &st, way, &casts).await?;
Ok(Json(json!({ "count": casts.len(), "entered": entered, "simulated": way == ServerWay::Simulated })))
}
/// The simulated confirmer (ADR 0012): while the chain is closed, a vote goes
/// through the same buffer as a vote of the chain — a sealed ballot, simulated
/// (no account, no amount, no wallet), proven at once for the identity of the
/// session, at block 0, then reconciled. Returns what entered into force.
pub(crate) async fn simulate(
state: &AppState,
requester: &str,
st: &DocState,
casts: &[Cast],
) -> AppResult<Vec<Entered>> {
let lines: Vec<ballot::Line> = casts
.iter()
.map(|c| ballot::Line {
proposal_id: c.proposal_id.clone(),
revision: u32::try_from(c.revision).unwrap_or(u32::MAX),
choice: c.choice,
})
.collect();
let salt = salt();
let sealed = ballot::seal(&st.doc.id, None, &lines, &salt).map_err(|_| AppError::Invalid("lines"))?;
let id = util::id();
let mut tx = state.db.begin().await?;
sqlx::query(
"INSERT INTO ballots (id, doc_id, requested_by, author, salt, digest, remark_hash, account, amount, status,
created_at, expires_at, mode)
VALUES (?, ?, ?, NULL, ?, ?, ?, '', 0, 'pending', ?, ?, 'simulated')",
)
.bind(&id)
.bind(&st.doc.id)
.bind(requester)
.bind(&salt)
.bind(&sealed.digest)
.bind(&sealed.remark_hash)
.bind(util::now())
.bind(util::in_seconds(EXPIRES_HOURS * 3600))
.execute(&mut *tx)
.await?;
for c in casts {
sqlx::query("INSERT INTO ballot_lines (ballot_id, proposal_id, revision, choice) VALUES (?, ?, ?, ?)")
.bind(&id)
.bind(&c.proposal_id)
.bind(c.revision)
.bind(c.choice.as_str())
.execute(&mut *tx)
.await?;
}
tx.commit().await?;
let row = load(state, &id).await?;
settle_simulated(state, &row).await
}
/// Proves a simulated ballot: the voice of the session that asked for it.
pub async fn settle_simulated(state: &AppState, row: &BallotRow) -> AppResult<Vec<Entered>> {
settle(state, row, Proof { voter: row.requested_by.clone(), position: None, found: None }).await
}
#[derive(Deserialize)]
pub struct DevChainBody {
open: bool,
}
/// `POST /api/dev/vote-chain` — tests only, with the dev login: closes (or opens
/// again) the chain of this server, to try the simulation (ADR 0012).
pub async fn dev_chain(State(state): State<AppState>, Json(b): Json<DevChainBody>) -> AppResult<Json<serde_json::Value>> {
if !state.cfg.dev_login {
return Err(AppError::NotFound);
}
state.chain_closed.store(!b.open, Ordering::Relaxed);
Ok(Json(json!({ "open": state.chain().is_some() })))
}
// ---------------------------------------------------------------------------
@@ -210,15 +352,34 @@ pub struct BallotRow {
pub created_at: String,
pub expires_at: String,
pub checked_at: Option<String>,
/// `chain`, or `simulated` (ADR 0012); read as `chain` when absent.
#[sqlx(default)]
pub mode: String,
#[sqlx(default)]
pub settled_at: Option<String>,
}
const BALLOT_SELECT: &str = "SELECT id, doc_id, requested_by, author, digest, remark_hash, account, amount, status,
reason, voter_id, block, entered, created_at, expires_at, checked_at FROM ballots";
reason, voter_id, block, entered, created_at, expires_at, checked_at, mode, settled_at FROM ballots";
impl BallotRow {
pub fn comment(&self) -> String {
format!("{}{}", ballot::PREFIX, self.digest)
}
/// A ballot of the simulation, proven by the simulated confirmer.
pub fn simulated(&self) -> bool {
self.mode == "simulated"
}
pub fn mode(&self) -> &'static str {
if self.simulated() { "simulated" } else { "chain" }
}
/// Where it sits on the chain: never for a simulated ballot (block 0 orders it only).
pub fn block_shown(&self) -> Option<i64> {
self.block.filter(|_| !self.simulated())
}
}
fn salt() -> String {
@@ -244,7 +405,7 @@ pub async fn create(
if !trustin_access::asks_ballot(&user.to_identity(), &group, granted) {
return Err(AppError::Forbidden);
}
let chain = state.cfg.vote.as_ref().ok_or(AppError::Conflict("chain_vote_off"))?;
let chain = state.chain().ok_or(AppError::Conflict("chain_vote_off"))?;
let casts = casts(&st, &b.lines)?;
let author = match b.author.as_deref().map(str::trim).filter(|a| !a.is_empty()) {
Some(a) => Some(address::to_g1(a).ok_or(AppError::Invalid("author"))?),
@@ -252,7 +413,7 @@ pub async fn create(
};
// Pending, or let go within the hour: letting a ballot go does not free its place at once.
let held: i64 = sqlx::query_scalar(
"SELECT COUNT(*) FROM ballots WHERE requested_by = ?
"SELECT COUNT(*) FROM ballots WHERE requested_by = ? AND mode = 'chain'
AND (status = 'pending' OR (reason = 'dropped' AND settled_at > ?))",
)
.bind(&user.id)
@@ -329,7 +490,9 @@ pub async fn status(
if row.requested_by != user.id {
return Err(AppError::NotFound);
}
if row.status == "pending" && row.checked_at.as_ref().is_none_or(|c| *c < util::in_seconds(-RECHECK_SECS)) {
if row.status == "pending"
&& (row.simulated() || row.checked_at.as_ref().is_none_or(|c| *c < util::in_seconds(-RECHECK_SECS)))
{
check(&state, &row).await?;
row = load(&state, &id).await?;
}
@@ -386,9 +549,10 @@ pub async fn mine(State(state): State<AppState>, User(user): User) -> AppResult<
lines: i64,
created_at: String,
settled_at: Option<String>,
mode: String,
}
let rows = sqlx::query_as::<_, Row>(&format!(
"SELECT b.id, b.doc_id, d.group_slug, d.slug, d.title, b.digest, b.status, b.reason, b.block,
"SELECT b.id, b.doc_id, d.group_slug, d.slug, d.title, b.digest, b.status, b.reason, b.block, b.mode,
i.display_name AS voter, (SELECT COUNT(*) FROM ballot_lines l WHERE l.ballot_id = b.id) AS lines,
b.created_at, b.settled_at
FROM ballots b JOIN documents d ON d.id = b.doc_id LEFT JOIN identities i ON i.id = b.voter_id
@@ -404,7 +568,9 @@ pub async fn mine(State(state): State<AppState>, User(user): User) -> AppResult<
json!({
"id": r.id, "doc": { "id": r.doc_id, "group": r.group_slug, "slug": r.slug, "title": title_json(&r.title) },
"comment": format!("{}{}", ballot::PREFIX, r.digest), "status": r.status, "reason": r.reason,
"block": r.block, "voter": r.voter, "lines": r.lines, "createdAt": r.created_at, "settledAt": r.settled_at,
"block": r.block.filter(|_| r.mode != "simulated"), "voter": r.voter, "lines": r.lines,
"createdAt": r.created_at, "settledAt": r.settled_at,
"mode": if r.mode == "simulated" { "simulated" } else { "chain" },
})
})
.collect();
@@ -495,7 +661,8 @@ pub async fn receipt(State(state): State<AppState>, User(user): User, Path(id):
"amount": row.amount,
"status": row.status,
"reason": row.reason,
"block": row.block,
"mode": row.mode(),
"block": row.block_shown(),
"event": extra.event_id,
"signer": extra.signer,
"voter": voter,
@@ -527,14 +694,17 @@ async fn view(state: &AppState, row: &BallotRow) -> AppResult<serde_json::Value>
row.entered.as_deref().and_then(|e| serde_json::from_str(e).ok()).unwrap_or_else(|| json!([]));
Ok(json!({
"id": row.id, "status": row.status, "reason": row.reason, "comment": row.comment(),
"account": row.account, "amount": row.amount, "author": row.author, "block": row.block,
"voter": voter, "entered": entered, "expiresAt": row.expires_at,
"account": row.account, "amount": row.amount, "author": row.author, "block": row.block_shown(),
"voter": voter, "entered": entered, "expiresAt": row.expires_at, "mode": row.mode(),
}))
}
/// Reads the indexer for one pending ballot and settles it if the chain has spoken
/// — in a final block. At its end, a ballot is read one last time, then let go.
pub async fn check(state: &AppState, row: &BallotRow) -> AppResult<()> {
if row.simulated() {
return settle_simulated(state, row).await.map(|_| ());
}
let now = util::now();
let due = row.expires_at <= now;
let past_grace = row.expires_at <= util::in_seconds(-GRACE_SECS);
@@ -576,7 +746,9 @@ pub async fn check(state: &AppState, row: &BallotRow) -> AppResult<()> {
match verdict {
// The right to vote is checked now, at confirmation, by trustinWallet's rule.
Verdict::Paid { identity } if trustin_access::chain_vote_counts(identity.member) => {
confirm(state, row, found, identity.index).await
let proof =
Proof { voter: format!("idty:{}", identity.index), position: Some(found.comment.position), found: Some(found) };
settle(state, row, proof).await.map(|_| ())
}
Verdict::Paid { .. } => refuse(state, row, found, "not_member").await,
other => refuse(state, row, found, other.reason().unwrap_or("refused")).await,
@@ -599,153 +771,256 @@ async fn refuse(state: &AppState, row: &BallotRow, found: &Found, reason: &str)
.await?;
if done.rows_affected() == 1 {
tracing::info!(ballot = %row.id, reason, "ballot refused");
tell(state, &row.id, &row.requested_by, &row.doc_id, "ballot_refused").await?;
}
Ok(())
}
/// The ballot counts: written for the identity of the signer, line by line,
/// where no more recent ballot of that identity decided already. A ballot sealed
/// before an objection counts as it was signed — a *for* too, as a vote already
/// cast —, and the version held back still cannot enter (ADR 0010).
async fn confirm(state: &AppState, row: &BallotRow, found: &Found, index: u32) -> AppResult<()> {
let voter = format!("idty:{index}");
let position = found.comment.position;
/// Tells the session that asked for a ballot what became of it (ADR 0012): a
/// message of its box, without gesture — one votes again in the text.
async fn tell(state: &AppState, ballot_id: &str, requester: &str, doc_id: &str, kind: &str) -> AppResult<()> {
messages::notify(state, requester, doc_id, Topic::Ballot, ballot_id, kind, 1, None).await
}
/// The proof of a ballot: whose voice it is, and where it sits on the chain.
pub struct Proof<'a> {
/// `idty:<index>` of the signer; for a simulated ballot, the identity of the
/// session that asked (there is no wallet).
pub voter: String,
/// `None`: a simulated ballot — block 0, at the next rank of the simulation.
pub position: Option<ChainPosition>,
/// What the chain said of the comment (account, name, event); none in simulation.
pub found: Option<&'a Found>,
}
/// The ballot is proven: confirmed for its voter, then each of its versions is
/// reconciled (`reconcile`). A *for* proven while an objection holds its
/// version back is set aside, and told (ADR 0012, revising 0010: it no longer
/// counts « as it was signed »). Proving twice changes nothing. Returns what
/// entered into force.
async fn settle(state: &AppState, row: &BallotRow, proof: Proof<'_>) -> AppResult<Vec<Entered>> {
let now = util::now();
{
// The versions an objection holds back now (read before the transaction: one writer).
let held = docs::load_state(state, &row.doc_id).await?.blocked;
let mut set_aside = false;
let position = {
let _one = CONFIRM.lock().await;
let mut tx = state.db.begin().await?;
// The identity of the signer, as the chain has it now: a member (just
// checked), with its name and its account. Undone with the rest if the
// ballot was settled in the meantime.
let admin = state.cfg.admin_g1_ids.contains(&voter);
sqlx::query(
"INSERT INTO identities (id, kind, display_name, address, g1_member, admin, created_at)
VALUES (?, 'g1', ?, ?, 1, ?, ?)
ON CONFLICT(id) DO UPDATE SET display_name = excluded.display_name, address = excluded.address,
g1_member = 1, admin = MAX(identities.admin, excluded.admin)",
)
.bind(&voter)
.bind(found.name.clone().unwrap_or_else(|| voter.clone()))
.bind(&found.signer)
.bind(admin)
.bind(&now)
.execute(&mut *tx)
.await?;
if let Some(found) = proof.found {
// The identity of the signer, as the chain has it now: a member (just
// checked), with its name and its account. Undone with the rest if the
// ballot was settled in the meantime.
let admin = state.cfg.admin_g1_ids.contains(&proof.voter);
sqlx::query(
"INSERT INTO identities (id, kind, display_name, address, g1_member, admin, created_at)
VALUES (?, 'g1', ?, ?, 1, ?, ?)
ON CONFLICT(id) DO UPDATE SET display_name = excluded.display_name, address = excluded.address,
g1_member = 1, admin = MAX(identities.admin, excluded.admin)",
)
.bind(&proof.voter)
.bind(found.name.clone().unwrap_or_else(|| proof.voter.clone()))
.bind(&found.signer)
.bind(admin)
.bind(&now)
.execute(&mut *tx)
.await?;
}
let position = match proof.position {
Some(p) => p,
None => {
let last: i64 = sqlx::query_scalar(
"SELECT IFNULL(MAX(event_index), 0) FROM ballots WHERE mode = 'simulated' AND status = 'confirmed'",
)
.fetch_one(&mut *tx)
.await?;
ChainPosition { block: 0, event: u32::try_from(last.saturating_add(1)).unwrap_or(u32::MAX) }
}
};
let won = sqlx::query(
"UPDATE ballots SET status = 'confirmed', voter_id = ?, signer = ?, block = ?, event_index = ?,
event_id = ?, settled_at = ? WHERE id = ? AND status = 'pending'",
)
.bind(&voter)
.bind(&found.signer)
.bind(&proof.voter)
.bind(proof.found.map(|f| &f.signer))
.bind(i64::from(position.block))
.bind(i64::from(position.event))
.bind(&found.event_id)
.bind(proof.found.map(|f| &f.event_id))
.bind(&now)
.bind(&row.id)
.execute(&mut *tx)
.await?;
if won.rows_affected() != 1 {
// Settled in the meantime: confirming twice changes nothing.
// Settled in the meantime: proving twice changes nothing.
tx.rollback().await?;
return Ok(());
return Ok(Vec::new());
}
let lines: Vec<(String, i64, String)> =
sqlx::query_as("SELECT proposal_id, revision, choice FROM ballot_lines WHERE ballot_id = ?")
let lines: Vec<(String, String)> =
sqlx::query_as("SELECT proposal_id, choice FROM ballot_lines WHERE ballot_id = ?")
.bind(&row.id)
.fetch_all(&mut *tx)
.await?;
for (proposal_id, revision, choice) in lines {
let others: Vec<(i64, i64)> = sqlx::query_as(
"SELECT b.block, b.event_index FROM ballots b JOIN ballot_lines l ON l.ballot_id = b.id
WHERE b.status = 'confirmed' AND b.voter_id = ? AND l.proposal_id = ? AND b.id <> ?
AND b.block IS NOT NULL AND b.event_index IS NOT NULL",
)
.bind(&voter)
.bind(&proposal_id)
.bind(&row.id)
.fetch_all(&mut *tx)
.await?;
let others: Vec<ChainPosition> = others
.into_iter()
.filter_map(|(b, e)| {
Some(ChainPosition { block: u32::try_from(b).ok()?, event: u32::try_from(e).ok()? })
})
.collect();
if !ballot::decides(position, &others) {
for (proposal_id, choice) in &lines {
let Some(choice) = Choice::parse(choice) else {
tracing::warn!(ballot = %row.id, %choice, "unknown choice in a ballot line");
continue;
}
match Choice::parse(&choice) {
Some(Choice::None) => {
sqlx::query("DELETE FROM votes WHERE proposal_id = ? AND identity_id = ?")
.bind(&proposal_id)
.bind(&voter)
.execute(&mut *tx)
.await?;
}
Some(c) => {
sqlx::query(
"INSERT INTO votes (proposal_id, identity_id, choice, revision, cast_at, source, block, event_index, ballot_id)
VALUES (?, ?, ?, ?, ?, 'chain', ?, ?, ?)
ON CONFLICT(proposal_id, identity_id) DO UPDATE SET choice = excluded.choice,
revision = excluded.revision, cast_at = excluded.cast_at, source = 'chain',
block = excluded.block, event_index = excluded.event_index, ballot_id = excluded.ballot_id",
)
.bind(&proposal_id)
.bind(&voter)
.bind(c.as_str())
.bind(revision)
.bind(&now)
.bind(i64::from(position.block))
.bind(i64::from(position.event))
};
if buffer::discarded_by_objection(choice, held.contains(proposal_id)) {
sqlx::query("UPDATE ballot_lines SET outcome = ? WHERE ballot_id = ? AND proposal_id = ?")
.bind(Outcome::Objection.as_str())
.bind(&row.id)
.bind(proposal_id)
.execute(&mut *tx)
.await?;
}
None => tracing::warn!(ballot = %row.id, %choice, "unknown choice in a ballot line"),
set_aside = true;
}
}
for (proposal_id, _) in &lines {
reconcile(&mut tx, &proof.voter, proposal_id, &now).await?;
}
tx.commit().await?;
}
tracing::info!(ballot = %row.id, block = position.block, event = position.event, "ballot confirmed");
position
};
tracing::info!(ballot = %row.id, mode = row.mode(), block = position.block, event = position.event, "ballot proven");
let entered: Vec<Entered> = adoption::run(state, &row.doc_id).await?;
sqlx::query("UPDATE ballots SET entered = ? WHERE id = ?")
.bind(serde_json::to_string(&entered).unwrap_or_else(|_| "[]".into()))
.bind(&row.id)
.execute(&state.db)
.await?;
if set_aside {
tell(state, &row.id, &row.requested_by, &row.doc_id, "ballot_objection").await?;
}
Ok(entered)
}
/// The reconciliation of one identity on one version (ADR 0012): every proven
/// line of it, read again; one voice, the last in the order of the chain
/// (`ld_engine::buffer::reconcile`), whatever the order the proofs came in. Each
/// line is told what became of it; the voice that stands is written in `votes`
/// — or, every line set aside, the vote of before is left as it is.
pub async fn reconcile(conn: &mut SqliteConnection, voter: &str, proposal_id: &str, now: &str) -> AppResult<()> {
#[derive(sqlx::FromRow)]
struct Row {
ballot_id: String,
mode: String,
block: Option<i64>,
event_index: Option<i64>,
revision: i64,
choice: String,
outcome: Option<String>,
}
let rows = sqlx::query_as::<_, Row>(
"SELECT b.id AS ballot_id, b.mode, b.block, b.event_index, l.revision, l.choice, l.outcome
FROM ballots b JOIN ballot_lines l ON l.ballot_id = b.id
WHERE b.status = 'confirmed' AND b.voter_id = ? AND l.proposal_id = ?
ORDER BY b.block, b.event_index, b.created_at, b.rowid",
)
.bind(voter)
.bind(proposal_id)
.fetch_all(&mut *conn)
.await?;
let mut kept: Vec<(&Row, Proven)> = Vec::with_capacity(rows.len());
for r in &rows {
let position = r.block.zip(r.event_index).and_then(|(b, e)| {
Some(ChainPosition { block: u32::try_from(b).ok()?, event: u32::try_from(e).ok()? })
});
let (Some(position), Some(choice)) = (position, Choice::parse(&r.choice)) else {
tracing::warn!(ballot = %r.ballot_id, "a proven line that does not read back");
continue;
};
let held = r.outcome.as_deref() == Some(Outcome::Objection.as_str());
kept.push((r, Proven { position, choice, held }));
}
let lines: Vec<Proven> = kept.iter().map(|(_, p)| *p).collect();
let done = buffer::reconcile(&lines);
for ((r, _), outcome) in kept.iter().zip(&done.outcomes) {
if r.outcome.as_deref() != Some(outcome.as_str()) {
sqlx::query("UPDATE ballot_lines SET outcome = ? WHERE ballot_id = ? AND proposal_id = ?")
.bind(outcome.as_str())
.bind(&r.ballot_id)
.bind(proposal_id)
.execute(&mut *conn)
.await?;
}
}
let Some((r, line)) = done.standing.and_then(|i| kept.get(i)) else { return Ok(()) };
match line.choice {
Choice::None => {
sqlx::query("DELETE FROM votes WHERE proposal_id = ? AND identity_id = ?")
.bind(proposal_id)
.bind(voter)
.execute(&mut *conn)
.await?;
}
c => {
// Only when it changes: the same ballot standing again keeps its row as it is.
sqlx::query(
"INSERT INTO votes (proposal_id, identity_id, choice, revision, cast_at, source, block, event_index, ballot_id)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(proposal_id, identity_id) DO UPDATE SET choice = excluded.choice,
revision = excluded.revision, cast_at = excluded.cast_at, source = excluded.source,
block = excluded.block, event_index = excluded.event_index, ballot_id = excluded.ballot_id
WHERE votes.ballot_id IS NOT excluded.ballot_id",
)
.bind(proposal_id)
.bind(voter)
.bind(c.as_str())
.bind(r.revision)
.bind(now)
.bind(if r.mode == "simulated" { "simulated" } else { "chain" })
.bind(i64::from(line.position.block))
.bind(i64::from(line.position.event))
.bind(&r.ballot_id)
.execute(&mut *conn)
.await?;
}
}
Ok(())
}
/// Lets go of one pending ballot not seen on the chain in time.
async fn let_go(state: &AppState, row: &BallotRow) -> AppResult<()> {
sqlx::query("UPDATE ballots SET status = 'expired', settled_at = ? WHERE id = ? AND status = 'pending'")
let done = sqlx::query("UPDATE ballots SET status = 'expired', settled_at = ? WHERE id = ? AND status = 'pending'")
.bind(util::now())
.bind(&row.id)
.execute(&state.db)
.await?;
if done.rows_affected() == 1 {
tell(state, &row.id, &row.requested_by, &row.doc_id, "ballot_expired").await?;
}
Ok(())
}
/// Lets go of the pending ballots past their end and the grace after it: those
/// the indexer could not be read for in time.
pub async fn expire(state: &AppState) -> AppResult<u64> {
let done = sqlx::query(
"UPDATE ballots SET status = 'expired', settled_at = ? WHERE status = 'pending' AND expires_at <= ?",
let gone: Vec<(String, String, String)> = sqlx::query_as(
"UPDATE ballots SET status = 'expired', settled_at = ?
WHERE status = 'pending' AND mode = 'chain' AND expires_at <= ?
RETURNING id, requested_by, doc_id",
)
.bind(util::now())
.bind(util::in_seconds(-GRACE_SECS))
.execute(&state.db)
.fetch_all(&state.db)
.await?;
Ok(done.rows_affected())
for (id, requester, doc_id) in &gone {
tell(state, id, requester, doc_id, "ballot_expired").await?;
}
Ok(u64::try_from(gone.len()).unwrap_or(u64::MAX))
}
/// Purges the ballots let go long enough ago, lines and all. A ballot let go
/// never counted: nothing of a vote is lost.
/// Purges the ballots let go long enough ago, lines and all, and the messages
/// that told of them. A ballot let go never counted: nothing of a vote is lost.
pub async fn purge(state: &AppState) -> AppResult<u64> {
const WHICH: &str = "SELECT id FROM ballots WHERE status = 'expired' AND settled_at IS NOT NULL
AND ((reason = 'dropped' AND settled_at < ?) OR settled_at < ?)";
let (dropped, expired) = (util::in_seconds(-PURGE_DROPPED_SECS), util::in_seconds(-PURGE_EXPIRED_SECS));
let mut tx = state.db.begin().await?;
sqlx::query(&format!("DELETE FROM messages WHERE topic = 'ballot' AND subject_id IN ({WHICH})"))
.bind(&dropped)
.bind(&expired)
.execute(&mut *tx)
.await?;
sqlx::query(&format!("DELETE FROM ballot_lines WHERE ballot_id IN ({WHICH})"))
.bind(&dropped)
.bind(&expired)
@@ -766,8 +1041,19 @@ pub async fn purge(state: &AppState) -> AppResult<u64> {
pub async fn sweep(state: &AppState) -> AppResult<usize> {
expire(state).await?;
purge(state).await?;
// The simulated confirmer: a simulated ballot is proven in its own request; one
// left waiting (a stop in between) is proven here.
let simulated =
sqlx::query_as::<_, BallotRow>(&format!("{BALLOT_SELECT} WHERE status = 'pending' AND mode = 'simulated'"))
.fetch_all(&state.db)
.await?;
for row in &simulated {
if let Err(e) = settle_simulated(state, row).await {
tracing::warn!(ballot = %row.id, error = %e, "simulated ballot");
}
}
let rows = sqlx::query_as::<_, BallotRow>(&format!(
"{BALLOT_SELECT} WHERE status = 'pending'
"{BALLOT_SELECT} WHERE status = 'pending' AND mode = 'chain'
ORDER BY checked_at IS NOT NULL, checked_at, created_at, rowid LIMIT {PER_PASS}"
))
.fetch_all(&state.db)
@@ -823,8 +1109,9 @@ pub async fn my_votes(state: &AppState, me: &str, doc_id: &str) -> AppResult<Has
Ok(rows.into_iter().map(|v| (v.proposal_id.clone(), v)).collect())
}
/// What a ballot of the person, not yet counted, says of one version: pending on
/// the chain, or refused, or let go.
/// What a ballot of the person, not counted, says of one version: pending on the
/// chain (an intention, ADR 0012), refused, let go — or its *for* set aside by an
/// objection (`refused`, reason `objection`).
#[derive(Clone, Debug, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MyBallot {
@@ -832,12 +1119,16 @@ pub struct MyBallot {
pub status: String,
pub reason: Option<String>,
pub choice: String,
/// The revision the line votes.
#[serde(skip)]
pub revision: i64,
}
/// Per version: the most recent pending ballot of `me` asked after its last
/// confirmed one; else its most recent ballot if that one was refused or let go
/// (a confirmed one shows as its vote). A ballot the wallet never signed
/// (dropped) says nothing; one asked before a confirmed vote says nothing either.
/// confirmed one; else its most recent ballot if that one was refused or let go,
/// or proven with its line set aside by an objection (a confirmed one shows as its
/// vote). A ballot the wallet never signed (dropped) says nothing; one asked
/// before a confirmed vote says nothing either.
pub async fn my_ballots(state: &AppState, me: &str, doc_id: &str) -> AppResult<HashMap<String, MyBallot>> {
#[derive(sqlx::FromRow)]
struct Row {
@@ -846,9 +1137,11 @@ pub async fn my_ballots(state: &AppState, me: &str, doc_id: &str) -> AppResult<H
status: String,
reason: Option<String>,
choice: String,
revision: i64,
outcome: Option<String>,
}
let rows = sqlx::query_as::<_, Row>(
"SELECT l.proposal_id, b.id, b.status, b.reason, l.choice FROM ballots b
"SELECT l.proposal_id, b.id, b.status, b.reason, l.choice, l.revision, l.outcome FROM ballots b
JOIN ballot_lines l ON l.ballot_id = b.id
WHERE b.doc_id = ? AND b.requested_by = ? AND IFNULL(b.reason, '') <> 'dropped'
ORDER BY b.created_at, b.rowid",
@@ -860,7 +1153,14 @@ pub async fn my_ballots(state: &AppState, me: &str, doc_id: &str) -> AppResult<H
let mut latest: HashMap<String, MyBallot> = HashMap::new();
let mut pending: HashMap<String, MyBallot> = HashMap::new();
for r in rows {
let b = MyBallot { id: r.id, status: r.status, reason: r.reason, choice: r.choice };
let set_aside = r.status == "confirmed" && r.outcome.as_deref() == Some(Outcome::Objection.as_str());
let b = MyBallot {
id: r.id,
status: if set_aside { "refused".into() } else { r.status },
reason: if set_aside { Some(Outcome::Objection.as_str().into()) } else { r.reason },
choice: r.choice,
revision: r.revision,
};
match b.status.as_str() {
// A confirmed vote: what was asked before it says nothing more.
"confirmed" => {
@@ -871,6 +1171,9 @@ pub async fn my_ballots(state: &AppState, me: &str, doc_id: &str) -> AppResult<H
pending.insert(r.proposal_id, b);
}
_ => {
if set_aside {
pending.remove(&r.proposal_id);
}
latest.insert(r.proposal_id, b);
}
}
@@ -879,29 +1182,137 @@ pub async fn my_ballots(state: &AppState, me: &str, doc_id: &str) -> AppResult<H
Ok(latest)
}
/// The latest intention of a session on a version, still waiting for its proof.
pub struct Intent {
pub requester: String,
pub proposal_id: String,
pub revision: i64,
pub choice: Choice,
}
/// The intentions of a document (ADR 0012): for each session and each version,
/// its most recent pending ballot of the chain asked after its last confirmed one
/// on that version — the rule of `my_ballots`, for everyone.
pub async fn intents(state: &AppState, doc_id: &str) -> AppResult<Vec<Intent>> {
#[derive(sqlx::FromRow)]
struct Row {
requested_by: String,
proposal_id: String,
revision: i64,
choice: String,
}
let rows = sqlx::query_as::<_, Row>(
"SELECT b.requested_by, l.proposal_id, l.revision, l.choice FROM ballots b
JOIN ballot_lines l ON l.ballot_id = b.id
WHERE b.doc_id = ? AND b.status = 'pending' AND b.mode = 'chain'
AND NOT EXISTS (SELECT 1 FROM ballots c JOIN ballot_lines cl ON cl.ballot_id = c.id
WHERE c.requested_by = b.requested_by AND cl.proposal_id = l.proposal_id
AND c.status = 'confirmed'
AND (c.created_at > b.created_at OR (c.created_at = b.created_at AND c.rowid > b.rowid)))
ORDER BY b.created_at, b.rowid",
)
.bind(doc_id)
.fetch_all(&state.db)
.await?;
let mut latest: HashMap<(String, String), Intent> = HashMap::new();
for r in rows {
let Some(choice) = Choice::parse(&r.choice) else { continue };
let key = (r.requested_by.clone(), r.proposal_id.clone());
latest.insert(key, Intent { requester: r.requested_by, proposal_id: r.proposal_id, revision: r.revision, choice });
}
Ok(latest.into_values().collect())
}
/// « Ton vote » as the person sees it now (ADR 0012): its latest gesture — an
/// intention still waiting for the chain — or the vote that counts for it.
pub struct Seen {
pub choice: Option<String>,
/// `recorded`, `pending`, `simulated`, or none.
pub state: Option<&'static str>,
/// It votes a revision gone by: « to reconfirm ».
pub stale: bool,
/// Proven on the chain.
pub chain: bool,
}
pub fn seen(revision: i64, vote: Option<&MyVote>, ballot: Option<&MyBallot>) -> Seen {
if let Some(b) = ballot.filter(|b| b.status == "pending") {
let choice = (b.choice != Choice::None.as_str()).then(|| b.choice.clone());
return Seen {
stale: choice.is_some() && b.revision != revision,
choice,
state: Some(Stage::Pending.as_str()),
chain: false,
};
}
match vote {
Some(v) => Seen {
choice: Some(v.choice.clone()),
state: Some(Stage::of_source(&v.source).as_str()),
stale: v.revision != revision,
chain: v.source == "chain",
},
None => Seen { choice: None, state: None, stale: false, chain: false },
}
}
/// A ballot, for a message of the box of the session that asked for it (ADR
/// 0012): what became of it, line by line. No gesture: one votes again in the text.
pub async fn for_message(state: &AppState, viewer: &IdentityRow, id: &str) -> AppResult<Option<serde_json::Value>> {
#[derive(sqlx::FromRow)]
struct LineRow {
proposal_id: String,
unit_id: String,
code: String,
title: String,
choice: String,
outcome: Option<String>,
}
let row = sqlx::query_as::<_, BallotRow>(&format!("{BALLOT_SELECT} WHERE id = ?"))
.bind(id)
.fetch_optional(&state.db)
.await?;
let Some(row) = row.filter(|r| r.requested_by == viewer.id) else { return Ok(None) };
let lines = sqlx::query_as::<_, LineRow>(
"SELECT l.proposal_id, p.unit_id, u.code, p.title, l.choice, l.outcome FROM ballot_lines l
JOIN proposals p ON p.id = l.proposal_id JOIN units u ON u.id = p.unit_id
WHERE l.ballot_id = ? ORDER BY u.position, u.id",
)
.bind(id)
.fetch_all(&state.db)
.await?;
Ok(Some(json!({
"id": row.id, "status": row.status, "reason": row.reason, "mode": row.mode(),
"createdAt": row.created_at, "settledAt": row.settled_at,
"lines": lines.iter().map(|l| json!({
"proposalId": l.proposal_id, "unitId": l.unit_id, "code": l.code, "title": l.title,
"choice": l.choice, "outcome": l.outcome,
})).collect::<Vec<_>>(),
})))
}
/// How this session votes in a group, and whether it may now.
pub async fn access(state: &AppState, user: &IdentityRow, group: &docs::GroupRow) -> AppResult<serde_json::Value> {
let g = group.to_group();
let granted = docs::granted(state, &g.slug, &user.id).await?;
let id = user.to_identity();
let way = trustin_access::vote_way(&g);
let (open, reason) = match way {
VoteWay::Server => {
let open = trustin_access::votes_in(&id, &g, granted);
(open, (!open).then_some("members_only"))
}
VoteWay::Chain => match (&state.cfg.vote, trustin_access::asks_ballot(&id, &g, granted)) {
(None, _) => (false, Some("chain_off")),
(Some(_), false) => (false, Some("members_only")),
(Some(_), true) => (true, None),
},
// While the chain is closed, a group of the chain votes in simulation: the vote
// leaves the page by a write of the server, marked as simulated (ADR 0012).
let simulated = way == VoteWay::Chain && state.chain().is_none();
let open = match way {
VoteWay::Server => trustin_access::votes_in(&id, &g, granted),
VoteWay::Chain if simulated => trustin_access::casts_simulated(&id, &g, granted, false),
VoteWay::Chain => trustin_access::asks_ballot(&id, &g, granted),
};
let chain = match (way, &state.cfg.vote) {
let reason = (!open).then_some("members_only");
let chain = match (way, state.chain()) {
(VoteWay::Chain, Some(c)) => json!({
"account": c.account, "amount": c.amount, "nodes": c.nodes,
"test": c.test_node.is_some(), "testNode": c.test_node, "expiresHours": EXPIRES_HOURS,
}),
_ => serde_json::Value::Null,
};
Ok(json!({ "way": way, "open": open, "reason": reason, "chain": chain }))
let leaves = if simulated { VoteWay::Server } else { way };
Ok(json!({ "way": leaves, "open": open, "simulated": simulated, "reason": reason, "chain": chain }))
}
crates/ld-server/src/config.rs
+5
View File
@@ -73,6 +73,9 @@ pub struct Config {
pub build: String,
/// The vote on the chain; `None` = off (no `LD_VOTE_ACCOUNT`).
pub vote: Option<VoteChain>,
/// Whether a simulated vote counts for adoption while the chain is closed
/// (ADR 0012): `ld_engine::buffer::SIMULATED_ADOPTS`, the default of lot V.
pub simulated_adopts: bool,
}
fn var(name: &str) -> Option<String> {
@@ -152,6 +155,7 @@ impl Config {
wot_fallback: var("LD_WOT_FALLBACK").and_then(|v| v.parse().ok()).unwrap_or(5745),
build: var("LD_BUILD").unwrap_or_else(|| "dev".into()),
vote,
simulated_adopts: ld_engine::buffer::SIMULATED_ADOPTS,
data_dir,
}
}
@@ -183,6 +187,7 @@ impl Config {
wot_fallback: 5745,
build: "test".into(),
vote: None,
simulated_adopts: ld_engine::buffer::SIMULATED_ADOPTS,
}
}
}
crates/ld-server/src/docs.rs
+103 -18
View File
@@ -13,6 +13,7 @@ use crate::util::{self, LangMap};
use axum::Json;
use axum::extract::{Path, Query, State};
use ld_engine::ballot::Choice;
use ld_engine::buffer::{self, Rules, Stage};
use ld_engine::compose::{self, PreviewMode, ProposalKind, ProposalState, UnitState, VersionText};
use ld_engine::inertia::{InertiaLevel, Participation, Scale};
use ld_engine::threshold::{Evaluation, Tally};
@@ -265,7 +266,21 @@ pub struct DocState {
/// The units that are modules (ADR 0009), by unit id; any other is an article.
pub module_kinds: HashMap<String, ModuleKind>,
pub proposals: Vec<ProposalRow>,
/// What adoption counts (ADR 0012): recorded votes, and simulated ones by
/// default — never an intention without proof.
pub tallies: HashMap<String, Tally>,
/// What is recorded and shown: recorded votes and simulated ones, without the
/// intentions (what a published text may say).
pub recorded: HashMap<String, Tally>,
/// The totals shown: `recorded`, each intention in place of the vote its
/// session sees as its own (`ld_engine::buffer::weigh_intent`).
pub shown: HashMap<String, Tally>,
/// The part of `shown` still waiting for its proof.
pub pending: HashMap<String, Tally>,
/// The part of `shown` that comes from the simulation.
pub simulated: HashMap<String, Tally>,
/// What each stage of a vote weighs.
pub rules: Rules,
/// Versions held back by a standing objection: against or a withdrawal only, never
/// a new *for* (`admits`), and never entering into force.
pub blocked: HashSet<String>,
@@ -333,30 +348,70 @@ pub async fn load_state(state: &AppState, doc_id: &str) -> AppResult<DocState> {
struct TallyRow {
proposal_id: String,
choice: String,
source: String,
n: i64,
}
let rows = sqlx::query_as::<_, TallyRow>(
"SELECT v.proposal_id, v.choice, COUNT(*) AS n FROM votes v JOIN proposals p ON p.id = v.proposal_id
"SELECT v.proposal_id, v.choice, v.source, COUNT(*) AS n FROM votes v JOIN proposals p ON p.id = v.proposal_id
JOIN units u ON u.id = p.unit_id
WHERE u.doc_id = ? AND v.revision = p.revision GROUP BY v.proposal_id, v.choice",
WHERE u.doc_id = ? AND v.revision = p.revision GROUP BY v.proposal_id, v.choice, v.source",
)
.bind(doc_id)
.fetch_all(&state.db)
.await?;
let mut tallies: HashMap<String, Tally> = HashMap::new();
for r in rows {
let t = tallies.entry(r.proposal_id).or_default();
let n = u32::try_from(r.n).unwrap_or(0);
match r.choice.as_str() {
"for" => t.for_votes = n,
"against" => t.against = n,
let rules = state.vote_rules();
let add = |map: &mut HashMap<String, Tally>, id: &str, choice: &str, n: u32| {
let t = map.entry(id.to_owned()).or_default();
match choice {
"for" => t.for_votes = t.for_votes.saturating_add(n),
"against" => t.against = t.against.saturating_add(n),
_ => {}
}
};
let (mut tallies, mut recorded, mut simulated) = (HashMap::new(), HashMap::new(), HashMap::new());
for r in rows {
let n = u32::try_from(r.n).unwrap_or(0);
let stage = Stage::of_source(&r.source);
if rules.adopts(stage) {
add(&mut tallies, &r.proposal_id, &r.choice, n);
}
if rules.shown(stage) {
add(&mut recorded, &r.proposal_id, &r.choice, n);
if stage == Stage::Simulated {
add(&mut simulated, &r.proposal_id, &r.choice, n);
}
}
}
// A standing objection holds back the latest arrival of its pair (never a version
// in force): no new *for*, and it cannot enter into force (ADR 0010).
let (blocked, signal_counts) = crate::objections::held(state, doc_id, &units).await?;
// The intentions (ADR 0012): seen at once in the totals shown, in place of the
// vote their session sees as its own; never counted for adoption.
let mut shown = recorded.clone();
let mut pending: HashMap<String, Tally> = HashMap::new();
let mut seen_by: HashMap<String, HashMap<String, MyVote>> = HashMap::new();
for i in ballots::intents(state, doc_id).await? {
let Some(p) = proposals.iter().find(|p| p.id == i.proposal_id) else { continue };
if !matches!(p.status.as_str(), "open" | "in_force") {
continue;
}
if !seen_by.contains_key(&i.requester) {
seen_by.insert(i.requester.clone(), ballots::my_votes(state, &i.requester, doc_id).await?);
}
let seen = seen_by
.get(&i.requester)
.and_then(|m| m.get(&p.id))
.filter(|v| v.revision == p.revision)
.and_then(|v| Choice::parse(&v.choice));
let w = buffer::weigh_intent(seen, i.choice, i.revision == p.revision, blocked.contains(&p.id));
let t = shown.entry(p.id.clone()).or_default();
*t = w.shift.apply(*t);
let q = pending.entry(p.id.clone()).or_default();
q.for_votes = q.for_votes.saturating_add(w.pending.for_votes);
q.against = q.against.saturating_add(w.pending.against);
}
let (electorate, electorate_source) = electorate(state, &group).await?;
let measure = participation::stored(state, &group.slug).await?;
let participation = Participation::of(
@@ -373,6 +428,11 @@ pub async fn load_state(state: &AppState, doc_id: &str) -> AppResult<DocState> {
module_kinds,
proposals,
tallies,
recorded,
shown,
pending,
simulated,
rules,
blocked,
signal_counts,
electorate,
@@ -397,13 +457,34 @@ impl DocState {
self.tallies.get(id).copied().unwrap_or_default()
}
/// The totals shown to people: today the live count, as `tally`. The one
/// place where a publication by steps would plug in — on the chain, who
/// voted and when is public, and live totals tell what (the secret of the
/// vote, review of 74f96be, a decision that waits for Yvv). Adoption reads
/// `tally`; the published texts (`publish.rs`) would follow this one.
/// The totals shown to people: the live count, intentions included (ADR
/// 0012: « je vois ce que j'ai fait sans attendre »). The one place where a
/// publication by steps would plug in — on the chain, who voted and when is
/// public, and live totals tell what (the secret of the vote, review of
/// 74f96be). Adoption reads `tally`, never an intention.
pub fn shown_tally(&self, id: &str) -> Tally {
self.tally(id)
self.shown.get(id).copied().unwrap_or_default()
}
/// The part of `shown_tally` still waiting for its proof.
pub fn pending_tally(&self, id: &str) -> Tally {
self.pending.get(id).copied().unwrap_or_default()
}
/// The part of `shown_tally` that comes from the simulation.
pub fn simulated_tally(&self, id: &str) -> Tally {
self.simulated.get(id).copied().unwrap_or_default()
}
/// What is recorded and shown, without the intentions: what a published text says.
pub fn recorded_tally(&self, id: &str) -> Tally {
self.recorded.get(id).copied().unwrap_or_default()
}
/// The simulated share of what adoption counts for a version (zero when the
/// simulation counts for display only).
pub fn simulated_counted(&self, id: &str) -> Tally {
if self.rules.adopts(Stage::Simulated) { self.simulated_tally(id) } else { Tally::default() }
}
/// How far the threshold is, as shown: on `shown_tally`.
@@ -641,6 +722,7 @@ fn proposal_json(
me: &str,
) -> serde_json::Value {
let (mine, ballot) = mine;
let seen = ballots::seen(p.revision, mine, ballot);
let eval = st.shown_evaluation(unit, p);
let (kind, target) = match p.kind() {
// A module's version says what it holds (ADR 0009).
@@ -661,14 +743,17 @@ fn proposal_json(
"submittedAt": p.submitted_at, "enteredAt": p.entered_at, "confirmedAt": p.confirmed_at,
"seedMinimal": p.status == "in_force" && p.entered_at.is_none() && p.confirmed_at.is_none() && p.origin == "seed",
"tally": st.shown_tally(&p.id),
"tallyPending": st.pending_tally(&p.id),
"tallySimulated": st.simulated_tally(&p.id),
"evaluation": eval,
"votedAtInertia": voted_at,
"blocked": st.blocked.contains(&p.id),
"votable": st.votable(p),
"objections": st.signal_counts.get(&p.id).copied().unwrap_or(0),
"myVote": mine.map(|v| v.choice.as_str()),
"myVoteStale": mine.is_some_and(|v| v.revision != p.revision),
"myVoteChain": mine.is_some_and(|v| v.source == "chain"),
"myVote": seen.choice,
"myVoteState": seen.state,
"myVoteStale": seen.stale,
"myVoteChain": seen.chain,
"myBallot": ballot,
"translations": translations.cloned().unwrap_or_default(),
})
crates/ld-server/src/lib.rs
+20 -1
View File
@@ -4,7 +4,8 @@
//! and runs four background workers: the electorate refresher (size of the Ğ1
//! web of trust), the adoption sweeper (with the deadlines of three days of
//! objections and typo fixes), the ballot watcher (votes signed on the Ğ1 chain,
//! confirmed on the indexer) and the publisher (adopted texts pushed to the git
//! confirmed on the indexer, or simulated while the chain is closed — ADR 0012)
//! and the publisher (adopted texts pushed to the git
//! repository that client applications read).
pub mod access;
@@ -30,6 +31,7 @@ pub mod proposals;
pub mod publish;
pub mod seed;
pub mod seed_amend;
pub mod simulation;
pub mod team;
pub mod typos;
pub mod util;
@@ -46,6 +48,7 @@ use sqlx::SqlitePool;
use sqlx::sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions};
use std::str::FromStr;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use tokio::sync::Notify;
@@ -62,6 +65,9 @@ pub struct AppState {
pub upcoming: Arc<overview::Upcoming>,
/// The clock of the deadlines of three days (objections, typo fixes); tests move it.
pub clock: clock::Clock,
/// Tests only, with the dev login: the chain of this server closed for a while
/// (`POST /api/dev/vote-chain`), to try the simulation (ADR 0012).
pub chain_closed: Arc<AtomicBool>,
}
impl AppState {
@@ -78,8 +84,20 @@ impl AppState {
publish_wake: Arc::new(Notify::new()),
upcoming,
clock: clock::Clock::default(),
chain_closed: Arc::new(AtomicBool::new(false)),
})
}
/// The vote on the chain, as it is now: `None` while it is closed (no vote
/// account, or closed for a test) — the vote is then simulated (ADR 0012).
pub fn chain(&self) -> Option<&config::VoteChain> {
self.cfg.vote.as_ref().filter(|_| !self.chain_closed.load(Ordering::Relaxed))
}
/// What each stage of a vote weighs (ADR 0012).
pub fn vote_rules(&self) -> ld_engine::buffer::Rules {
ld_engine::buffer::Rules { simulated_adopts: self.cfg.simulated_adopts }
}
}
/// Open (or create) the database and apply migrations.
@@ -159,6 +177,7 @@ pub fn api_router() -> Router<AppState> {
.route("/messages/read", post(messages::read_all))
.route("/messages/{id}/read", post(messages::read))
.route("/dev/clock", post(deadlines::dev_clock))
.route("/dev/vote-chain", post(ballots::dev_chain))
.route("/units/{id}/inertia", post(proposals::propose_inertia))
.route("/units/{id}/order", post(order::propose))
.route("/units/{id}/title", post(doc_title::propose))
crates/ld-server/src/main.rs
+8 -1
View File
@@ -1,6 +1,13 @@
//! libreDecision server — entry point. Everything else lives in the library.
//!
//! `ld-server discard-simulation [--apply]` is the act « supprime » that ends the
//! simulation of the vote (ADR 0012): never run by the server itself.
#[tokio::main]
async fn main() -> anyhow::Result<()> {
ld_server::run().await
let args: Vec<String> = std::env::args().skip(1).collect();
match args.first().map(String::as_str) {
Some("discard-simulation") => ld_server::simulation::run_cli(args.iter().any(|a| a == "--apply")).await,
_ => ld_server::run().await,
}
}
crates/ld-server/src/messages.rs
+11 -2
View File
@@ -1,7 +1,8 @@
//! The messages of trustinWallet (2026-10-31, lot F, ADR 0010): a box in the
//! application, in the menu, with the number of unread messages — no mail.
//!
//! A message is about a subject (an objection, a typo fix) and carries the
//! A message is about a subject (an objection, a typo fix, a ballot set aside —
//! ADR 0012) and carries the
//! gestures that subject asks of its recipient now — lift or reiterate,
//! validate or refuse — and its deadline. A message dealt with offers no
//! gesture any more. Its text is told by the interface, in the language of the
@@ -12,7 +13,7 @@
use crate::AppState;
use crate::auth::{IdentityRow, User};
use crate::error::{AppError, AppResult};
use crate::{docs, objections, typos, util};
use crate::{ballots, docs, objections, typos, util};
use axum::Json;
use axum::extract::{Path, State};
use serde_json::{Value, json};
@@ -24,6 +25,9 @@ const SHOWN: i64 = 100;
pub enum Topic {
Objection,
Typo,
/// A ballot set aside: never seen on the chain in time, refused, or its *for*
/// proven while an objection held the version back (ADR 0012).
Ballot,
}
impl Topic {
@@ -31,6 +35,7 @@ impl Topic {
match self {
Self::Objection => "objection",
Self::Typo => "typo",
Self::Ballot => "ballot",
}
}
}
@@ -168,6 +173,10 @@ async fn view(state: &AppState, me: &IdentityRow, m: &MessageRow) -> AppResult<O
Some((v, g)) => (json!({ "typo": v }), g),
None => return Ok(None),
},
"ballot" => match ballots::for_message(state, me, &m.subject_id).await? {
Some(v) => (json!({ "ballot": v }), Vec::new()),
None => return Ok(None),
},
_ => return Ok(None),
};
let mut out = json!({
crates/ld-server/src/overview.rs
+6 -2
View File
@@ -160,10 +160,14 @@ async fn modules(state: &AppState, doc_id: &str, me: &str) -> AppResult<Vec<Modu
"SELECT p.id AS id, u.id AS unit_id,
IFNULL(p.id = u.in_force_id, 0) AS in_force,
(p.entered_at IS NOT NULL OR p.confirmed_at IS NOT NULL OR p.origin <> 'seed') AS adopted,
EXISTS (SELECT 1 FROM votes v
(EXISTS (SELECT 1 FROM votes v
WHERE v.proposal_id = p.id AND v.revision = p.revision
AND (v.identity_id = ?1 OR v.ballot_id IN
(SELECT b.id FROM ballots b WHERE b.requested_by = ?1 AND b.status = 'confirmed'))) AS voted
(SELECT b.id FROM ballots b WHERE b.requested_by = ?1 AND b.status = 'confirmed')))
-- An intention still waiting for the chain is one's vote already (ADR 0012).
OR EXISTS (SELECT 1 FROM ballots b JOIN ballot_lines l ON l.ballot_id = b.id
WHERE b.requested_by = ?1 AND b.status = 'pending' AND b.mode = 'chain'
AND l.proposal_id = p.id AND l.revision = p.revision AND l.choice <> 'none')) AS voted
FROM units u JOIN proposals p ON p.unit_id = u.id
WHERE u.doc_id = ?2 AND p.kind <> 'inertia' AND (p.id = u.in_force_id OR p.status = 'open')
ORDER BY u.position, u.id",
crates/ld-server/src/participation.rs
+3
View File
@@ -51,10 +51,13 @@ pub async fn sample(state: &AppState, group: &str, since: &str) -> sqlx::Result<
JOIN units u ON u.id = p.unit_id
JOIN documents d ON d.id = u.doc_id
WHERE d.group_slug = ? AND p.status IN ('open', 'in_force', 'applied') AND v.revision = p.revision
AND (v.source <> 'simulated' OR ?)
GROUP BY v.proposal_id
HAVING MAX(v.cast_at) >= ?",
)
.bind(group)
// The simulated votes weigh here as they weigh in adoption (ADR 0012).
.bind(state.vote_rules().adopts(ld_engine::buffer::Stage::Simulated))
.bind(since)
.fetch_all(&state.db)
.await?;
crates/ld-server/src/proposals.rs
+12 -13
View File
@@ -586,6 +586,7 @@ pub async fn detail(
let my_vote = ballots::my_votes(&state, &user.id, &st.doc.id).await?.remove(&id);
let my_ballot = ballots::my_ballots(&state, &user.id, &st.doc.id).await?.remove(&id);
let seen = ballots::seen(p.revision, my_vote.as_ref(), my_ballot.as_ref());
let diff = match (&in_force, p.kind.as_str()) {
(Some(v), "text") => Some(edit::diff(&v.body, &p.body)),
_ => None,
@@ -602,11 +603,11 @@ pub async fn detail(
"mine": p.author_id.as_deref() == Some(user.id.as_str()),
"submittedAt": p.submitted_at, "enteredAt": p.entered_at, "confirmedAt": p.confirmed_at,
"seedMinimal": p.status == "in_force" && p.entered_at.is_none() && p.confirmed_at.is_none() && p.origin == "seed",
"tally": st.shown_tally(&p.id), "evaluation": eval, "votedAtInertia": voted_at,
"tally": st.shown_tally(&p.id), "tallyPending": st.pending_tally(&p.id),
"tallySimulated": st.simulated_tally(&p.id), "evaluation": eval, "votedAtInertia": voted_at,
"blocked": st.blocked.contains(&p.id), "votable": st.votable(&p),
"myVote": my_vote.as_ref().map(|v| &v.choice),
"myVoteStale": my_vote.as_ref().is_some_and(|v| v.revision != p.revision),
"myVoteChain": my_vote.as_ref().is_some_and(|v| v.source == "chain"), "myBallot": my_ballot,
"myVote": seen.choice, "myVoteState": seen.state, "myVoteStale": seen.stale,
"myVoteChain": seen.chain, "myBallot": my_ballot,
"translations": tr.get(&p.id).cloned().unwrap_or_default(),
},
"unit": { "id": unit.id, "code": unit.code, "inertia": docs::inertia_of(unit) },
@@ -633,8 +634,9 @@ pub struct VoteBody {
choice: Option<String>,
}
/// One vote on the server, in a managed group. Where the vote goes through the
/// chain (Monnaie libre), it is a ballot (`ballots::create`), never this.
/// One vote written by the server: in a managed group, or in simulation while
/// the chain is closed (ADR 0012). Where the vote goes through the chain and the
/// chain is open (Monnaie libre), it is a ballot (`ballots::create`), never this.
pub async fn vote(
State(state): State<AppState>,
User(user): User,
@@ -642,9 +644,7 @@ pub async fn vote(
Json(b): Json<VoteBody>,
) -> AppResult<Json<serde_json::Value>> {
let (p, st) = guarded(&state, &user, &id).await?;
if trustin_access::vote_way(&st.group.to_group()) == trustin_access::VoteWay::Chain {
return Err(AppError::Conflict("chain_only"));
}
let way = ballots::server_way(&state, &st.group)?;
if !matches!(p.status.as_str(), "open" | "in_force") {
return Err(AppError::Conflict("not_votable"));
}
@@ -659,13 +659,12 @@ pub async fn vote(
if !st.admits(&p, choice) {
return Err(AppError::Conflict("objection"));
}
if !docs::may_vote(&state, &user, &st.group).await? {
if !ballots::may_write(&state, &user, &st.group, way).await? {
return Err(AppError::Conflict("members_only"));
}
let cast = ballots::Cast { proposal_id: p.id.clone(), revision: p.revision, choice };
ballots::write_server_votes(&state, &user.id, &[cast]).await?;
let entered = adoption::run(&state, &st.doc.id).await?;
Ok(Json(json!({ "entered": entered })))
let entered = ballots::write(&state, &user, &st, way, &[cast]).await?;
Ok(Json(json!({ "entered": entered, "simulated": way == ballots::ServerWay::Simulated })))
}
// ---------------------------------------------------------------------------
crates/ld-server/src/publish.rs
+2 -2
View File
@@ -390,7 +390,7 @@ async fn modules_json(state: &AppState, st: &DocState) -> anyhow::Result<serde_j
m.iter().map(|(l, t)| (l.clone(), json!({ "title": t["title"], "stale": t["stale"] }))).collect()
})
.unwrap_or_default();
let tally = st.shown_tally(&p.id);
let tally = st.recorded_tally(&p.id);
json!({
"inertia": crate::docs::inertia_of(u), "status": status(p), "enteredAt": p.entered_at,
"votes": { "for": tally.for_votes, "against": tally.against }, "translations": translations,
@@ -409,7 +409,7 @@ async fn modules_json(state: &AppState, st: &DocState) -> anyhow::Result<serde_j
.iter()
.filter_map(|id| st.units.iter().find(|x| &x.id == id).map(|x| x.code.as_str()))
.collect();
let tally = st.shown_tally(&p.id);
let tally = st.recorded_tally(&p.id);
Some(json!({
"section": section, "inertia": crate::docs::inertia_of(u), "status": status(p),
"enteredAt": p.entered_at, "votes": { "for": tally.for_votes, "against": tally.against },
crates/ld-server/src/simulation.rs
+269
View File
@@ -0,0 +1,269 @@
//! The end of the simulation (ADR 0012).
//!
//! Yvv, 2026-11-02: « Il compte, puis s'efface ». A simulated vote counts like a
//! proven one, marked as simulated, until an act « supprime » of Yvv sets every
//! one of them aside; what they brought into force is then examined again, with
//! the proven votes only. Opening the chain does none of this by itself: the act
//! calls `discard` — `ld-server discard-simulation` tells what it would do,
//! `ld-server discard-simulation --apply` does it. Never run on its own.
//!
//! - **The sort**: the simulated ballots, their lines, their votes and the
//! messages about them are deleted; each identity that voted in simulation is
//! reconciled again, so that a proven vote of its own, if any, stands.
//! - **The re-examination**: every entry into force that counted simulated votes
//! (`adoptions.params.simulated`), the most recent first, still in effect, is
//! judged again on the proven votes alone, at the level it was voted at. Below
//! its threshold, it **returns among the proposals** and the version it had
//! displaced comes back into force (a removed text comes back, a level of
//! inertia goes back, the order and the title of before apply again); its
//! adoption is void. At or above, it stays.
use crate::AppState;
use crate::adoption;
use crate::ballots;
use crate::docs::{self, DocState, ProposalRow, UnitRow};
use crate::error::AppResult;
use crate::modules;
use crate::proposals;
use crate::util;
use ld_engine::inertia::InertiaLevel;
use ld_engine::threshold::Tally;
use serde::Serialize;
use serde_json::Value;
/// One entry into force that counted simulated votes, judged again.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Reexamined {
pub doc_id: String,
pub proposal_id: String,
pub unit_id: String,
pub code: String,
/// `text`, `remove`, `inertia`, `order` or `title`.
pub kind: String,
pub at: String,
/// The votes it entered with, and the simulated share of them.
pub entered_with: Tally,
pub simulated: Tally,
/// The proven votes it holds now, and the *for* votes its level asks at them.
pub proven: Tally,
pub required: u32,
/// Still in force (or still applied): something else may have taken its place since.
pub in_effect: bool,
/// It holds on the proven votes alone: it stays.
pub holds: bool,
/// Returned among the proposals (`--apply` only).
pub returned: bool,
/// The version it had displaced, back in force when it returns.
pub displaced: Option<String>,
}
/// What the act does, or would do.
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Discarded {
/// Done (`--apply`), or only told.
pub applied: bool,
pub ballots: i64,
pub lines: i64,
pub votes: i64,
pub messages: i64,
pub reexamined: Vec<Reexamined>,
}
#[derive(sqlx::FromRow)]
struct AdoptionRow {
id: i64,
proposal_id: String,
unit_id: String,
doc_id: String,
kind: String,
votes_for: i64,
votes_against: i64,
params: String,
at: String,
}
fn tally_of(v: &Value) -> Tally {
serde_json::from_value(v.clone()).unwrap_or_default()
}
fn minus(a: Tally, b: Tally) -> Tally {
Tally { for_votes: a.for_votes.saturating_sub(b.for_votes), against: a.against.saturating_sub(b.against) }
}
/// Sets every simulated vote aside and examines again what they brought into
/// force — or, `apply` false, tells what it would do and changes nothing.
pub async fn discard(state: &AppState, apply: bool) -> AppResult<Discarded> {
const SIMULATED: &str = "SELECT id FROM ballots WHERE mode = 'simulated'";
let (ballots_n, lines, votes, messages): (i64, i64, i64, i64) = sqlx::query_as(&format!(
"SELECT (SELECT COUNT(*) FROM ballots WHERE mode = 'simulated'),
(SELECT COUNT(*) FROM ballot_lines WHERE ballot_id IN ({SIMULATED})),
(SELECT COUNT(*) FROM votes WHERE source = 'simulated'),
(SELECT COUNT(*) FROM messages WHERE topic = 'ballot' AND subject_id IN ({SIMULATED}))"
))
.fetch_one(&state.db)
.await?;
let mut out = Discarded { applied: apply, ballots: ballots_n, lines, votes, messages, reexamined: Vec::new() };
if apply {
// The sort: who voted in simulation, on what — reconciled again once their simulated lines are gone.
let pairs: Vec<(String, String)> = sqlx::query_as(
"SELECT DISTINCT b.voter_id, l.proposal_id FROM ballots b JOIN ballot_lines l ON l.ballot_id = b.id
WHERE b.mode = 'simulated' AND b.voter_id IS NOT NULL",
)
.fetch_all(&state.db)
.await?;
let now = util::now();
let mut tx = state.db.begin().await?;
for sql in [
format!("DELETE FROM messages WHERE topic = 'ballot' AND subject_id IN ({SIMULATED})"),
"DELETE FROM votes WHERE source = 'simulated'".to_owned(),
format!("DELETE FROM ballot_lines WHERE ballot_id IN ({SIMULATED})"),
"DELETE FROM ballots WHERE mode = 'simulated'".to_owned(),
] {
sqlx::query(&sql).execute(&mut *tx).await?;
}
for (voter, proposal_id) in &pairs {
ballots::reconcile(&mut tx, voter, proposal_id, &now).await?;
}
tx.commit().await?;
tracing::warn!(ballots = ballots_n, votes, "simulated votes set aside (act « supprime »)");
}
// The re-examination, the most recent entry first.
let adoptions = sqlx::query_as::<_, AdoptionRow>(
"SELECT id, proposal_id, unit_id, doc_id, kind, votes_for, votes_against, params, at FROM adoptions
ORDER BY at DESC, id DESC",
)
.fetch_all(&state.db)
.await?;
for a in adoptions {
let params: Value = serde_json::from_str(&a.params).unwrap_or(Value::Null);
let simulated = tally_of(&params["simulated"]);
if simulated.cast() == 0 {
continue;
}
if let Some(r) = reexamine(state, &a, &params, simulated, apply).await? {
out.reexamined.push(r);
}
}
Ok(out)
}
async fn reexamine(
state: &AppState,
a: &AdoptionRow,
params: &Value,
simulated: Tally,
apply: bool,
) -> AppResult<Option<Reexamined>> {
let st = docs::load_state(state, &a.doc_id).await?;
let Some(unit) = st.units.iter().find(|u| u.id == a.unit_id) else { return Ok(None) };
let Ok(p) = proposals::load_proposal(state, &a.proposal_id).await else { return Ok(None) };
let in_effect = match a.kind.as_str() {
"remove" => p.status == "applied" && unit.in_force_id.is_none(),
"inertia" => {
p.status == "applied" && p.inertia_target.as_deref().and_then(InertiaLevel::parse) == Some(docs::inertia_of(unit))
}
_ => unit.in_force_id.as_deref() == Some(p.id.as_str()),
};
// Applied: the simulated votes are gone. Told only: they still count, set them apart.
let proven = if apply { st.tally(&p.id) } else { minus(st.tally(&p.id), st.simulated_counted(&p.id)) };
let level = serde_json::from_value::<InertiaLevel>(params["level"].clone()).unwrap_or_else(|_| st.voting_level(unit, &p));
let eval = st.scale().evaluate(proven, level).ok();
let holds = eval.is_some_and(|e| e.reached);
let displaced = params["displaced"].as_str().map(str::to_owned);
let mut r = Reexamined {
doc_id: a.doc_id.clone(),
proposal_id: p.id.clone(),
unit_id: unit.id.clone(),
code: unit.code.clone(),
kind: a.kind.clone(),
at: a.at.clone(),
entered_with: Tally {
for_votes: u32::try_from(a.votes_for).unwrap_or(0),
against: u32::try_from(a.votes_against).unwrap_or(0),
},
simulated,
proven,
required: eval.map_or(0, |e| e.required),
in_effect,
holds,
returned: false,
displaced: displaced.clone(),
};
if apply && in_effect && !holds {
give_back(state, &st, unit, &p, a, params, displaced.as_deref()).await?;
r.returned = true;
}
Ok(Some(r))
}
/// An entry that does not hold on the proven votes: the version returns among the
/// proposals, the one it displaced comes back, and its adoption is void.
async fn give_back(
state: &AppState,
st: &DocState,
unit: &UnitRow,
p: &ProposalRow,
a: &AdoptionRow,
params: &Value,
displaced: Option<&str>,
) -> AppResult<()> {
let now = util::now();
let back = match displaced {
Some(d) => proposals::load_proposal(state, d).await.ok().filter(|v| v.status == "open"),
None => None,
};
let mut tx = state.db.begin().await?;
sqlx::query("UPDATE proposals SET status = 'open', entered_at = NULL, left_at = ?, updated_at = ? WHERE id = ?")
.bind(&now)
.bind(&now)
.bind(&p.id)
.execute(&mut *tx)
.await?;
if a.kind == "inertia" {
let from = serde_json::from_value::<InertiaLevel>(params["from_inertia"].clone()).unwrap_or_default();
sqlx::query("UPDATE units SET inertia = ? WHERE id = ?").bind(from.as_db()).bind(&unit.id).execute(&mut *tx).await?;
sqlx::query("DELETE FROM inertia_changes WHERE proposal_id = ? AND cause = 'vote'")
.bind(&p.id)
.execute(&mut *tx)
.await?;
} else {
if let Some(b) = &back {
sqlx::query("UPDATE proposals SET status = 'in_force', left_at = NULL, updated_at = ? WHERE id = ?")
.bind(&now)
.bind(&b.id)
.execute(&mut *tx)
.await?;
}
sqlx::query("UPDATE units SET in_force_id = ? WHERE id = ?")
.bind(back.as_ref().map(|b| &b.id))
.bind(&unit.id)
.execute(&mut *tx)
.await?;
// A module does more: the order of before moves its articles back, the title of before names the document.
if let (Some(b), Some(_)) = (&back, st.module_of(&unit.id)) {
let leaving = UnitRow { in_force_id: Some(p.id.clone()), ..unit.clone() };
modules::on_entry(&mut tx, st, &leaving, b).await?;
}
}
sqlx::query("DELETE FROM adoptions WHERE id = ?").bind(a.id).execute(&mut *tx).await?;
tx.commit().await?;
tracing::warn!(doc = %st.doc.id, unit = %unit.code, proposal = %p.id, "returned among the proposals: it does not hold on the proven votes");
adoption::enqueue_publication(state, &st.doc, &format!("votes simulés écartés : {} réexaminé", unit.code)).await?;
Ok(())
}
/// `ld-server discard-simulation [--apply]`: the act « supprime » of the end of
/// the simulation (ADR 0012). Without `--apply`, it tells what it would do.
pub async fn run_cli(apply: bool) -> anyhow::Result<()> {
let cfg = crate::Config::from_env();
let db_url = format!("sqlite://{}", cfg.data_dir.join("libredecision.db").display());
let db = crate::open_db(&db_url).await?;
let state = AppState::new(cfg, db).await?;
let done = discard(&state, apply).await.map_err(|e| anyhow::anyhow!("{e}"))?;
println!("{}", serde_json::to_string_pretty(&done)?);
Ok(())
}