myc

Self-custodial remote signer for Radroots apps
git clone https://radroots.dev/git/myc.git
Log | Files | Refs | README | LICENSE

commit 7827d4f32d22a6b7e20d7a87c6d6dad20aba061a
parent 3b485480f2b26fa48cf4776c981c1ddb5c8cd9a7
Author: triesap <tyson@radroots.org>
Date:   Tue, 13 Oct 2026 14:35:10 +0000

delivery: Skip targets whose attempts are exhausted

- Keep the first-ready selector consistent with the claim attempt ceiling.
- Prove required-target progress after an optional unknown acknowledgement.
- Retain unknown history and exact response bytes across state reopening.
- Verify the unchanged candidate with Rust 1.99.0 native, API and policy gates.

Diffstat:
Msrc/state_delivery.rs | 1+
Msrc/state_delivery_tests.rs | 193+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 190 insertions(+), 4 deletions(-)

diff --git a/src/state_delivery.rs b/src/state_delivery.rs @@ -53,6 +53,7 @@ FROM delivery_targets t JOIN delivery_jobs j ON j.job_id = t.job_id WHERE j.status IN ('pending', 'active') AND t.status IN ('pending', 'retryable', 'unknown') + AND t.attempt_count < j.max_attempts AND t.active_attempt_id IS NULL AND (t.next_attempt_at_unix_ms IS NULL OR t.next_attempt_at_unix_ms <= ?) ORDER BY j.created_at_unix_ms, t.job_id, t.target_index diff --git a/src/state_delivery_tests.rs b/src/state_delivery_tests.rs @@ -2,14 +2,17 @@ use std::{fs, os::unix::fs::PermissionsExt}; +use radroots_storage::event::SourceGeneration; + use crate::nip46_wave_080_a::{ - RECEIVED_AT_MS, configuration, connection_time, metadata, migration_evidence, runtime, + RECEIVED_AT_MS, configuration, connection_time, keys, metadata, migration_evidence, runtime, }; use crate::nip46_wave_080_b::{active_connection, atomic_response_request}; use crate::{ - MycDeliveryAttemptNonce, MycDeliveryAttemptOutcome, MycDeliveryClaim, MycDeliveryJobStatus, - MycDeliveryRelayId, MycDeliveryRetryJitter, MycDeliveryTargetStatus, MycDeliveryTimeUnixMs, - MycNip46CommitRequest, initialize_myc_state, open_myc_state_read_write, + MycConfigProfile, MycDeliveryAttemptNonce, MycDeliveryAttemptOutcome, MycDeliveryClaim, + MycDeliveryJobStatus, MycDeliveryRelayId, MycDeliveryRetryJitter, MycDeliveryTargetStatus, + MycDeliveryTimeUnixMs, MycNip46CommitRequest, MycStateMetadata, initialize_myc_state, + open_myc_state_read_write, parse_myc_config_v1, }; fn time(offset_ms: u64) -> MycDeliveryTimeUnixMs { @@ -253,3 +256,185 @@ async fn ready_target_selection_is_read_only_ordered_and_respects_delivery_state ); reopened.close().await.expect("reopened state close"); } + +#[tokio::test] +async fn ready_target_selection_skips_optional_unknown_at_attempt_ceiling() { + let directory = tempfile::tempdir().expect("temporary state root"); + let runtime = runtime(directory.path()); + fs::create_dir_all(runtime.context().paths().state()).expect("state directory"); + fs::set_permissions( + runtime.context().paths().state(), + fs::Permissions::from_mode(0o700), + ) + .expect("state directory mode"); + let source = include_str!("../contracts/services_hardening/config.v1.example.toml") + .replacen( + "4444444444444444444444444444444444444444444444444444444444444444", + &keys(2).public_key().to_hex(), + 1, + ) + .replacen( + "2222222222222222222222222222222222222222222222222222222222222222", + &keys(3).public_key().to_hex(), + 1, + ) + .replacen("required = true", "required = false", 1) + .replacen("max_attempts = 5", "max_attempts = 1", 1); + let configuration = parse_myc_config_v1(source.as_bytes(), MycConfigProfile::RepoLocal) + .expect("one optional target with one attempt"); + let metadata = MycStateMetadata::new( + &runtime, + &configuration, + SourceGeneration::new([0x5a; 32]).expect("fixture generation"), + RECEIVED_AT_MS, + ) + .expect("configuration-bound metadata"); + let (applied_at, build) = migration_evidence(); + initialize_myc_state(&runtime, &metadata, applied_at, &build) + .await + .expect("state initialization"); + let host = open_myc_state_read_write(&runtime, &metadata, applied_at, &build) + .await + .expect("writable state"); + let repository = host.repository(); + let (work, _, decision) = active_connection(&repository, &configuration).await; + let completion = MycNip46CommitRequest::new( + &work, + Some(&decision), + None, + connection_time(RECEIVED_AT_MS + 2_001), + ) + .expect("connection completion"); + let (request, signed_bytes) = atomic_response_request(&configuration, &completion); + let committed = repository + .commit_nip46_response(&request) + .await + .expect("atomic response and delivery commit"); + let job_id = committed.record().response().delivery_job().id(); + let primary = MycDeliveryRelayId::new("primary").expect("optional primary target"); + let secondary = MycDeliveryRelayId::new("secondary").expect("required secondary target"); + assert_eq!( + committed.record().response().delivery_job().max_attempts(), + 1 + ); + assert!(!committed.record().response().delivery_job().targets()[0].required()); + assert!(committed.record().response().delivery_job().targets()[1].required()); + let optional = match repository + .claim_delivery_target( + job_id, + &primary, + MycDeliveryAttemptNonce::from_injected_entropy([0xc1; 32]), + time(4_000), + ) + .await + .expect("optional target claim") + { + MycDeliveryClaim::Claimed(attempt) => attempt, + other => panic!("expected fresh optional claim: {other:?}"), + }; + repository + .mark_delivery_attempt_submitted(job_id, &primary, optional.id(), time(4_001)) + .await + .expect("record synthetic submission evidence"); + let active = repository + .record_delivery_attempt_outcome( + job_id, + &primary, + optional.id(), + MycDeliveryAttemptOutcome::UnknownAcknowledgement, + MycDeliveryRetryJitter::new(0).expect("zero jitter at attempt ceiling"), + time(4_002), + ) + .await + .expect("retain synthetic unknown acknowledgement"); + assert_eq!(active.status(), MycDeliveryJobStatus::Active); + let unknown = active.targets()[0].clone(); + assert_eq!(unknown.status(), MycDeliveryTargetStatus::Unknown); + assert_eq!(unknown.attempt_count(), 1); + assert_eq!(unknown.next_attempt_at(), None); + assert!(matches!( + repository + .claim_delivery_target( + job_id, + &primary, + MycDeliveryAttemptNonce::from_injected_entropy([0xc2; 32]), + time(4_003), + ) + .await + .expect("optional target has no remaining attempt"), + MycDeliveryClaim::Terminal + )); + assert_eq!( + repository + .next_ready_delivery_target(time(4_003)) + .await + .expect("select claimable required target"), + Some((job_id, secondary.clone())), + "an optional unknown target at its attempt ceiling must not starve required work" + ); + let required = match repository + .claim_delivery_target( + job_id, + &secondary, + MycDeliveryAttemptNonce::from_injected_entropy([0xc3; 32]), + time(4_003), + ) + .await + .expect("required target claim") + { + MycDeliveryClaim::Claimed(attempt) => attempt, + other => panic!("expected fresh required claim: {other:?}"), + }; + repository + .mark_delivery_attempt_submitted(job_id, &secondary, required.id(), time(4_004)) + .await + .expect("record required submission evidence"); + let delivered = repository + .record_delivery_attempt_outcome( + job_id, + &secondary, + required.id(), + MycDeliveryAttemptOutcome::Delivered, + MycDeliveryRetryJitter::new(0).expect("zero jitter"), + time(4_005), + ) + .await + .expect("synthetic required acknowledgement"); + assert_eq!(delivered.status(), MycDeliveryJobStatus::Delivered); + assert_eq!(delivered.targets()[0], unknown); + repository + .verify_delivery_invariants() + .await + .expect("delivery invariants retain the optional unknown evidence"); + host.close().await.expect("state close"); + + let reopened = open_myc_state_read_write(&runtime, &metadata, applied_at, &build) + .await + .expect("reopen state"); + let repository = reopened.repository(); + let retained = repository + .read_delivery_job(job_id) + .await + .expect("reopened job read") + .expect("retained job"); + assert_eq!(retained.status(), MycDeliveryJobStatus::Delivered); + assert_eq!(retained.targets()[0], unknown); + assert_eq!( + repository + .read_delivery_attempts(job_id, &primary) + .await + .expect("retained optional attempt") + .len(), + 1 + ); + assert_eq!( + repository + .read_nip46_response(job_id) + .await + .expect("reopened response read") + .expect("retained response") + .signed_response_bytes(), + signed_bytes + ); + reopened.close().await.expect("reopened state close"); +}