What causes "Active execution intent {} has no nonce" in nautechsystems/nautilus_trader?

Delete or mark the incomplete intent inactive so reconciliation skips it, then let the client create a fresh intent

Active execution intent

Error message

Active execution intent {} has no nonce

What it means

Reconciliation guard for unresolved execution intents: an active intent has no stored nonce, so its on-chain transaction state cannot be tracked or recovered; the intent is reported as unrecoverable instead of silently skipped.

Solutions

Delete or mark the incomplete intent inactive so reconciliation skips it, then let the client create a fresh intent
Backfill the nonce manually only if you can verify it matches the on-chain account nonce and stored signed bytes
Fix the writer path so nonce is persisted atomically with the intent

Defensive patterns

Strategy: validation

Validate before calling

let intent = database.get_active_execution_intent(chain_id, &wallet).await?;
if intent.as_ref().and_then(|i| i.nonce).is_none() {
    // deactivate the incomplete intent before connecting
}

Prevention

Persist the nonce atomically with intent creation
Mark intents inactive on early-phase failures
Monitor for intents stuck without a nonce

When it happens

Trigger: connect() -> reconcile_unresolved_execution(): intent passes schema and purpose checks but intent.nonce is None when recovered from the database.

Common situations: Intent row written in an early 'preparing' phase that crashed before nonce assignment; partial write; manual row insertion without a nonce.

Understand the failure class

Background: "must not be empty", "cannot be empty" — required-field validation errors across open-source libraries — this error's family across 41 libraries.

Related errors

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

Appendix: source

Thrown at crates/adapters/blockchain/src/execution/client.rs:1171

        if intent.status == "prepared" {
            database
                .mark_execution_intent_recoverable(intent.id)
                .await?;
            release_preparing_slot(&self.in_flight);
            return Ok(());
        }

        let purpose = TransactionPurpose::parse(&intent.purpose).ok_or_else(|| {
            anyhow::anyhow!(
                "Execution intent {} has unknown purpose {}",
                intent.id,
                intent.purpose
            )
        })?;
        let nonce = intent
            .nonce
            .ok_or_else(|| anyhow::anyhow!("Active execution intent {} has no nonce", intent.id))?;
        *self.in_flight.lock() = Some(InFlightSlot::Recovering(RecoveryTransaction {
            intent_id: intent.id,
            nonce,
            purpose,
        }));
        let hashes = database.get_execution_transaction_hashes(intent.id).await?;
        let current = current_execution_hash(intent.id, &hashes)?;
        let tx_hash = B256::from_str(&current.transaction_hash).with_context(|| {
            format!(
                "Execution intent {} has invalid transaction hash {}",
                intent.id, current.transaction_hash
            )
        })?;
        let policy = PayloadPolicy {
            chain_id: self.chain.chain_id,
            signer: self.wallet_address,
            gas_limit: self.config.gas_limit,
            max_fee_per_gas: self.config.max_fee_per_gas_wei,

View on GitHub (pinned to 18893faf8b)