What causes "Failed to commit verified action evidence: {e}" in nautechsystems/nautilus_trader?

Retry the entire record_execution_verification_batch call; the transaction rolled back so state is consistent

Failed to commit verified action evidence: {e}

Error message

Failed to commit verified action evidence: {e}

What it means

Transaction error in the verified-action evidence path: committing the transaction that persisted the evidence rows failed, so the evidence write was rolled back; the driver error is embedded in the message.

Source

Thrown at crates/adapters/blockchain/src/cache/database.rs:6168

            .bind(decision.read_class)
            .bind(height_start)
            .bind(height_end)
            .bind(batch.manifest_version)
            .bind(batch.manifest_digest)
            .bind(batch.provider_ids)
            .bind(batch.operator_ids)
            .bind(batch.failure_domain_ids)
            .bind(&decision.normalized_value_digest)
            .bind(revision)
            .bind(transition_key)
            .execute(&mut *transaction)
            .await
            .map_err(|e| anyhow::anyhow!("Failed to persist verified action evidence: {e}"))?;
        }
        transaction
            .commit()
            .await
            .map_err(|e| anyhow::anyhow!("Failed to commit verified action evidence: {e}"))?;
        Ok(())
    }

    pub(crate) async fn load_execution_replacement_cursor(
        &self,
        intent_id: i64,
        chain_id: u32,
        wallet_address: &str,
        nonce: u64,
        manifest_digest: &str,
    ) -> anyhow::Result<Option<ExecutionVerifiedHeader>> {
        let chain_id = i32::try_from(chain_id)
            .context("Replacement scan chain ID exceeds PostgreSQL INTEGER")?;
        let nonce =
            i64::try_from(nonce).context("Replacement scan nonce exceeds PostgreSQL BIGINT")?;
        let row = sqlx::query_as::<_, (i64, String, String, i64, Option<String>, String)>(
            "
            SELECT

View on GitHub (pinned to 18893faf8b)

Solutions

Retry the entire record_execution_verification_batch call; the transaction rolled back so state is consistent
Check Postgres logs for deadlock/serialization-failure details and reduce lock contention on the intent row
Verify pool/network stability (timeouts, idle connections being reaped)
Inspect the inner `{e}` source for the exact server error

Defensive patterns

Strategy: retry

Try / catch

if let Err(e) = db.record_execution_verification_batch(&batch).await {
    if e.to_string().contains("Failed to commit") {
        // transaction rolled back; safe to retry entire batch after backoff
        return retry_with_backoff(batch, 3).await;
    }
    return Err(e);
}

Prevention

Keep transactions short to reduce deadlock/window risk
Avoid lock ordering conflicts with other writers on execution_intent
Configure sane pool idle timeouts so connections survive the batch
Retry at the batch level; commit failure guarantees rollback

When it happens

Trigger: transaction.commit() fails: connection dropped between the inserts and commit, deadlock detected by Postgres, serialization failure, or the server terminating the session.

Common situations: Network partition or pool timeout during a long batch; Postgres deadlocking with another transaction locking execution_intent/execution_verification_decision rows; server restart mid-transaction.

Related errors

AI-assisted analysis of nautechsystems/nautilus_trader@18893faf8b (2026-09-08). Data as JSON: /api/errors/472c268f8f9428da. Report an issue: GitHub.