// Copyright (C) 2024-2026 Whiterun LLC
//
// This software is licensed under the GNU Affero General Public License (AGPL), version 3.0 or later.
// A copy of the license can be found in the LICENSE file or at https://www.gnu.org/licenses/agpl-3.0.html

//! Write path: index a block or mempool batch, mutate UTXO tables, roll back.

use anyhow::Result;
use bitcoin_hashes::Hash;
use bitcoincash::{BlockHash, TokenID, Transaction, Txid};
use log::debug;
use riftenlabs_defi::moria_v1_1::{
    crank_allowance_locking_bytecode, crank_hint_to_policy, decode_crank_hint,
    parse_moria_v11_from_tx, CrankPolicy, LoanCommitmentV11, MoriaV11ActionType, MoriaV11TokenIds,
    ParsedMoriaV11Action,
};
use sqlx::{Row, SqlitePool};

use crate::db::blob::ToBlob;

use super::{action_type_to_int, action_type_to_str, staking};

const BP_MESSAGE_SIZE: usize = 26;
/// `BP_TIMESTAMP_OFFSET` — u48 LE seconds.
const BP_TIMESTAMP_OFFSET: usize = 0;
/// `BP_BP_OFFSET` — u16 LE threshold in basis points.
const BP_BP_OFFSET: usize = 8;

/// Decode threshold_bp + oracle_timestamp from a 26-byte BP oracle commitment.
///
/// Layout: timestamp u48 LE @ 0, threshold u16 LE @ 8.
pub fn parse_bp_commitment(commitment: &[u8]) -> Option<(u16, u64)> {
    if commitment.len() != BP_MESSAGE_SIZE {
        return None;
    }
    let mut ts_bytes = [0u8; 8];
    ts_bytes[..6].copy_from_slice(&commitment[BP_TIMESTAMP_OFFSET..BP_TIMESTAMP_OFFSET + 6]);
    let oracle_timestamp = u64::from_le_bytes(ts_bytes);
    let threshold_bp = u16::from_le_bytes([commitment[BP_BP_OFFSET], commitment[BP_BP_OFFSET + 1]]);
    Some((threshold_bp, oracle_timestamp))
}

/// Build a minimal 26-byte BP commitment for tests (only timestamp + threshold filled).
#[cfg(test)]
pub fn encode_bp_commitment(threshold_bp: u16, oracle_timestamp: u64) -> Vec<u8> {
    let mut out = vec![0u8; BP_MESSAGE_SIZE];
    out[BP_TIMESTAMP_OFFSET..BP_TIMESTAMP_OFFSET + 6]
        .copy_from_slice(&oracle_timestamp.to_le_bytes()[..6]);
    out[BP_BP_OFFSET..BP_BP_OFFSET + 2].copy_from_slice(&threshold_bp.to_le_bytes());
    out
}

fn commitment_fields(c: &LoanCommitmentV11) -> (i64, i64, i64) {
    (
        c.principal as i64,
        c.annual_interest_rate_bp as i64,
        c.timestamp as i64,
    )
}

#[allow(clippy::too_many_arguments)]
pub(super) async fn insert_loan_utxo(
    pool: &SqlitePool,
    txid: &Txid,
    vout: u32,
    commitment: &LoanCommitmentV11,
    collateral_sats: u64,
    blockhash: &BlockHash,
) -> Result<()> {
    sqlx::query(
        "INSERT OR REPLACE INTO moria_v11_loan_utxo
         (txid, vout, borrower_hash, delegate_hash, principal, interest_rate,
          loan_timestamp, collateral_sats, blockhash)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
    )
    .bind(txid.to_blob())
    .bind(vout as i64)
    .bind(commitment.borrower_nft_hash.as_slice())
    .bind(commitment.delegate_nft_hash.as_slice())
    .bind(commitment.principal as i64)
    .bind(commitment.annual_interest_rate_bp as i64)
    .bind(commitment.timestamp as i64)
    .bind(collateral_sats as i64)
    .bind(blockhash.to_blob())
    .execute(pool)
    .await
    .map_err(|e| anyhow::anyhow!("failed to insert v11 loan utxo: {}", e))?;
    Ok(())
}

async fn delete_loan_utxo(pool: &SqlitePool, txid: &Txid, vout: u32) -> Result<()> {
    sqlx::query("DELETE FROM moria_v11_loan_utxo WHERE txid = ? AND vout = ?")
        .bind(txid.to_blob())
        .bind(vout as i64)
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!("failed to delete v11 loan utxo: {}", e))?;
    Ok(())
}

/// Look up a spent loan UTXO.
type LoanUtxoRow = (Vec<u8>, Vec<u8>, i64, i64, i64, i64);

async fn lookup_loan_utxo(
    pool: &SqlitePool,
    txid: &Txid,
    vout: u32,
) -> Result<Option<LoanUtxoRow>> {
    let row: Option<LoanUtxoRow> = sqlx::query_as(
        "SELECT borrower_hash, delegate_hash, principal, interest_rate, loan_timestamp,
                collateral_sats
         FROM moria_v11_loan_utxo WHERE txid = ? AND vout = ?",
    )
    .bind(txid.to_blob())
    .bind(vout as i64)
    .fetch_optional(pool)
    .await?;
    Ok(row)
}

#[allow(clippy::too_many_arguments)]
pub(super) async fn insert_allowance_utxo(
    pool: &SqlitePool,
    txid: &Txid,
    vout: u32,
    owner_hash: &[u8],
    delegate_hash: &[u8],
    locking_bytecode: &[u8],
    token_amount: i64,
    sats: u64,
    blockhash: &BlockHash,
    policy: Option<&CrankPolicy>,
    fee_sats: Option<i64>,
) -> Result<()> {
    sqlx::query(
        "INSERT OR REPLACE INTO moria_v11_allowance_utxo
         (txid, vout, owner_hash, delegate_hash, locking_bytecode, token_amount, sats, blockhash,
          policy_delta, policy_max_bp, policy_rescue_lead_bp,
          policy_up_leg_seconds, policy_down_leg_seconds, fee_sats)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
    )
    .bind(txid.to_blob())
    .bind(vout as i64)
    .bind(owner_hash)
    .bind(delegate_hash)
    .bind(locking_bytecode)
    .bind(token_amount)
    .bind(sats as i64)
    .bind(blockhash.to_blob())
    .bind(policy.map(|p| p.delta as i64))
    .bind(policy.map(|p| p.max_bp as i64))
    .bind(policy.map(|p| p.rescue_lead_bp as i64))
    .bind(policy.map(|p| p.up_leg_seconds as i64))
    .bind(policy.map(|p| p.down_leg_seconds as i64))
    .bind(fee_sats)
    .execute(pool)
    .await
    .map_err(|e| anyhow::anyhow!("failed to insert v11 allowance utxo: {}", e))?;
    Ok(())
}

async fn delete_allowance_utxo(pool: &SqlitePool, txid: &Txid, vout: u32) -> Result<()> {
    sqlx::query("DELETE FROM moria_v11_allowance_utxo WHERE txid = ? AND vout = ?")
        .bind(txid.to_blob())
        .bind(vout as i64)
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!("failed to delete v11 allowance utxo: {}", e))?;
    Ok(())
}

struct AllowanceUtxoRow {
    owner_hash: Vec<u8>,
    delegate_hash: Vec<u8>,
    policy: Option<CrankPolicy>,
    fee_sats: Option<i64>,
}

fn crank_policy_from_cols(
    delta: Option<i64>,
    max_bp: Option<i64>,
    rescue_lead_bp: Option<i64>,
    up_leg_seconds: Option<i64>,
    down_leg_seconds: Option<i64>,
) -> Option<CrankPolicy> {
    Some(CrankPolicy {
        delta: u32::try_from(delta?).ok()?,
        max_bp: u32::try_from(max_bp?).ok()?,
        rescue_lead_bp: u32::try_from(rescue_lead_bp?).ok()?,
        up_leg_seconds: u32::try_from(up_leg_seconds?).ok()?,
        down_leg_seconds: u32::try_from(down_leg_seconds?).ok()?,
    })
}

async fn lookup_allowance_utxo(
    pool: &SqlitePool,
    txid: &Txid,
    vout: u32,
) -> Result<Option<AllowanceUtxoRow>> {
    let row = sqlx::query(
        "SELECT owner_hash, delegate_hash, locking_bytecode, token_amount, sats,
                policy_delta, policy_max_bp, policy_rescue_lead_bp,
                policy_up_leg_seconds, policy_down_leg_seconds, fee_sats
         FROM moria_v11_allowance_utxo WHERE txid = ? AND vout = ?",
    )
    .bind(txid.to_blob())
    .bind(vout as i64)
    .fetch_optional(pool)
    .await?;
    Ok(row.map(|r| AllowanceUtxoRow {
        owner_hash: r.get("owner_hash"),
        delegate_hash: r.get("delegate_hash"),
        policy: crank_policy_from_cols(
            r.get("policy_delta"),
            r.get("policy_max_bp"),
            r.get("policy_rescue_lead_bp"),
            r.get("policy_up_leg_seconds"),
            r.get("policy_down_leg_seconds"),
        ),
        fee_sats: r.get("fee_sats"),
    }))
}

/// Known allowance locking scripts already seen as live UTXOs (first-spend
/// or borrow deposit). Used so later top-ups to the same P2SH32 are indexed.
/// Policy+fee ride along so a top-up does not wipe a verified hint.
struct KnownAllowanceScript {
    locking_bytecode: Vec<u8>,
    owner_hash: Vec<u8>,
    delegate_hash: Vec<u8>,
    policy: Option<CrankPolicy>,
    fee_sats: Option<i64>,
}

async fn known_allowance_scripts(pool: &SqlitePool) -> Result<Vec<KnownAllowanceScript>> {
    let mut out: Vec<KnownAllowanceScript> = Vec::new();
    let mut seen: std::collections::HashMap<Vec<u8>, usize> = std::collections::HashMap::new();

    let utxo_rows = sqlx::query(
        "SELECT locking_bytecode, owner_hash, delegate_hash,
                policy_delta, policy_max_bp, policy_rescue_lead_bp,
                policy_up_leg_seconds, policy_down_leg_seconds, fee_sats
         FROM moria_v11_allowance_utxo",
    )
    .fetch_all(pool)
    .await?;
    for row in utxo_rows {
        let script: Vec<u8> = row.get("locking_bytecode");
        let policy = crank_policy_from_cols(
            row.get("policy_delta"),
            row.get("policy_max_bp"),
            row.get("policy_rescue_lead_bp"),
            row.get("policy_up_leg_seconds"),
            row.get("policy_down_leg_seconds"),
        );
        let fee_sats: Option<i64> = row.get("fee_sats");
        if let Some(&idx) = seen.get(&script) {
            if out[idx].policy.is_none() && policy.is_some() {
                out[idx].policy = policy;
            }
            if out[idx].fee_sats.is_none() && fee_sats.is_some() {
                out[idx].fee_sats = fee_sats;
            }
            continue;
        }
        seen.insert(script.clone(), out.len());
        out.push(KnownAllowanceScript {
            locking_bytecode: script,
            owner_hash: row.get("owner_hash"),
            delegate_hash: row.get("delegate_hash"),
            policy,
            fee_sats,
        });
    }
    Ok(out)
}

async fn insert_bp_threshold(
    pool: &SqlitePool,
    txid: &Txid,
    blockhash: &BlockHash,
    threshold_bp: u16,
    oracle_timestamp: u64,
) -> Result<()> {
    sqlx::query(
        "INSERT OR REPLACE INTO moria_v11_bp_threshold
         (txid, blockhash, threshold_bp, oracle_timestamp)
         VALUES (?, ?, ?, ?)",
    )
    .bind(txid.to_blob())
    .bind(blockhash.to_blob())
    .bind(threshold_bp as i64)
    .bind(oracle_timestamp as i64)
    .execute(pool)
    .await
    .map_err(|e| anyhow::anyhow!("failed to insert v11 bp threshold: {}", e))?;
    Ok(())
}

#[allow(clippy::too_many_arguments)]
async fn insert_action(
    pool: &SqlitePool,
    txid: &Txid,
    blockhash: &BlockHash,
    mtp: i64,
    first_seen: Option<i64>,
    action: &ParsedMoriaV11Action,
    borrower_hash: Option<&[u8]>,
    delegate_hash: Option<&[u8]>,
) -> Result<()> {
    let old_c = action.loan_commitment.as_ref();
    let new_c = action.new_loan_commitment.as_ref();

    let bh = borrower_hash
        .or_else(|| old_c.map(|c| c.borrower_nft_hash.as_slice()))
        .or_else(|| new_c.map(|c| c.borrower_nft_hash.as_slice()));
    let dh = delegate_hash
        .or_else(|| old_c.map(|c| c.delegate_nft_hash.as_slice()))
        .or_else(|| new_c.map(|c| c.delegate_nft_hash.as_slice()));

    let has_old = old_c.is_some();
    let (principal, interest_rate, loan_timestamp) =
        old_c.map(commitment_fields).unwrap_or((0, 0, 0));

    let has_new = new_c.is_some();
    let (new_principal, new_interest_rate, new_loan_timestamp) =
        new_c.map(commitment_fields).unwrap_or((0, 0, 0));

    let allowance_token_amount = action
        .allowance_deposit
        .as_ref()
        .map(|d| d.token_amount)
        .or_else(|| {
            action
                .crank_allowance
                .as_ref()
                .map(|c| c.output_token_amount)
        });
    let allowance_sats = action
        .allowance_deposit
        .as_ref()
        .map(|d| d.sats as i64)
        .or_else(|| {
            action
                .crank_allowance
                .as_ref()
                .map(|c| c.output_sats as i64)
        });

    let fee_take_sats = action.crank_fee_sats.map(|s| s as i64);
    let recovered_token_amount = action.allowance_close.as_ref().map(|c| c.token_amount);
    let recovered_sats = action.allowance_close.as_ref().map(|c| c.sats as i64);

    let new_collateral_sats = if has_new {
        action.collateral_sats.map(|s| s as i64)
    } else {
        None
    };

    sqlx::query(
        "INSERT INTO moria_v11_action
         (txid, blockhash, action_type, borrower_hash, delegate_hash,
          principal, interest_rate, loan_timestamp,
          collateral_sats, tokens_amount, mtp_timestamp, first_seen_timestamp,
          new_principal, new_interest_rate, new_loan_timestamp, new_collateral_sats,
          allowance_token_amount, allowance_sats, fee_take_sats,
          recovered_token_amount, recovered_sats, loan_output_index)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
    )
    .bind(txid.to_blob())
    .bind(blockhash.to_blob())
    .bind(action_type_to_int(action.action_type))
    .bind(bh)
    .bind(dh)
    .bind(if has_old { Some(principal) } else { None })
    .bind(if has_old { Some(interest_rate) } else { None })
    .bind(if has_old { Some(loan_timestamp) } else { None })
    .bind(action.collateral_sats.map(|s| s as i64))
    .bind(action.tokens_amount)
    .bind(mtp)
    .bind(first_seen)
    .bind(if has_new { Some(new_principal) } else { None })
    .bind(if has_new {
        Some(new_interest_rate)
    } else {
        None
    })
    .bind(if has_new {
        Some(new_loan_timestamp)
    } else {
        None
    })
    .bind(new_collateral_sats)
    .bind(allowance_token_amount)
    .bind(allowance_sats)
    .bind(fee_take_sats)
    .bind(recovered_token_amount)
    .bind(recovered_sats)
    .bind(action.loan_output_index.map(|i| i as i64))
    .execute(pool)
    .await
    .map_err(|e| anyhow::anyhow!("failed to insert moria_v11_action: {}", e))?;
    Ok(())
}

fn index_bp_oracle_outputs(tx: &Transaction, bp_oracle: &TokenID) -> Option<(u16, u64)> {
    for out in &tx.output {
        let Some(tok) = out.token.as_ref() else {
            continue;
        };
        if &tok.id != bp_oracle {
            continue;
        }
        if let Some(parsed) = parse_bp_commitment(&tok.commitment) {
            return Some(parsed);
        }
    }
    None
}

fn verified_borrow_hint_policy(
    tx: &Transaction,
    token_ids: &MoriaV11TokenIds,
    commitment: &LoanCommitmentV11,
) -> Option<(CrankPolicy, u64)> {
    let seq = tx.input.get(4)?.sequence.to_consensus_u32();
    let hint = decode_crank_hint(seq)?;
    if token_ids.loan_locking_bytecode.is_empty() {
        return None;
    }
    let script = tx.output.get(8)?.script_pubkey.as_bytes();
    let policy = crank_hint_to_policy(&hint);
    let bp = token_ids.bp_oracle.to_byte_array();
    let mut bp_rev = bp;
    bp_rev.reverse();
    for cat in [&bp, &bp_rev] {
        let derived = crank_allowance_locking_bytecode(
            &token_ids.loan_locking_bytecode,
            &commitment.borrower_nft_hash,
            &commitment.delegate_nft_hash,
            hint.fee_sats,
            cat,
            &policy,
        );
        if script == derived.as_slice() || script.ends_with(derived.as_slice()) {
            return Some((policy, hint.fee_sats));
        }
    }
    None
}

/// Index moria v1-1 transactions from a block (or mempool batch).
///
/// Returns the number of loan/allowance actions recorded (BP threshold rows
/// are not included in the count).
pub async fn index_moria_v11(
    pool: &SqlitePool,
    txs: &[Transaction],
    blockhash: &BlockHash,
    mtp: i64,
    token_ids: &MoriaV11TokenIds,
) -> Result<usize> {
    let mut count = 0;

    for tx in txs {
        let txid = tx.compute_txid();
        if *blockhash != BlockHash::all_zeros() {
            delete_unconfirmed_tx(pool, &txid).await?;
        }

        // BP oracle threshold updates (independent of loan actions).
        if let Some((threshold_bp, oracle_ts)) = index_bp_oracle_outputs(tx, &token_ids.bp_oracle) {
            insert_bp_threshold(pool, &txid, blockhash, threshold_bp, oracle_ts).await?;
            debug!(
                "moria_v11 bp threshold: {} bp={} ts={}",
                txid, threshold_bp, oracle_ts
            );
        }

        // Discover allowances from borrow optional-MUSD or first spend.
        // Previously-seen UTXO scripts remain recognizable for top-ups.
        let known_scripts = known_allowance_scripts(pool).await?;
        if !known_scripts.is_empty() {
            for (vout, out) in tx.output.iter().enumerate() {
                let script = out.script_pubkey.as_bytes();
                let Some(known) = known_scripts
                    .iter()
                    .find(|k| k.locking_bytecode.as_slice() == script)
                else {
                    continue;
                };
                let Some(tok) = out.token.as_ref() else {
                    continue;
                };
                if tok.id != token_ids.moria || tok.has_nft() {
                    continue;
                }
                let amount = tok.amount.to_int();
                if amount <= 0 {
                    continue;
                }
                insert_allowance_utxo(
                    pool,
                    &txid,
                    vout as u32,
                    &known.owner_hash,
                    &known.delegate_hash,
                    script,
                    amount,
                    out.value.to_sat(),
                    blockhash,
                    known.policy.as_ref(),
                    known.fee_sats,
                )
                .await?;
            }
        }

        let actions = parse_moria_v11_from_tx(tx, token_ids);

        // Track which allowance outpoints this tx's actions explicitly handle,
        // so the generic spend cleanup does not double-delete mid-action.
        let mut handled_allowance_spends: Vec<(Txid, u32)> = Vec::new();

        for mut action in actions {
            let mut looked_up_borrower: Option<Vec<u8>> = None;
            let mut looked_up_delegate: Option<Vec<u8>> = None;

            // Fill prior commitment from the live loan UTXO set when the parser
            // could not recover it (bare txs lack input token payloads).
            if let Some((spent_txid, spent_vout)) = &action.spent_loan_outpoint {
                if let Some((bh, dh, principal, interest_rate, loan_ts, collateral)) =
                    lookup_loan_utxo(pool, spent_txid, *spent_vout).await?
                {
                    if action.loan_commitment.is_none() {
                        let mut borrower = [0u8; 32];
                        let mut delegate = [0u8; 32];
                        if bh.len() == 32 {
                            borrower.copy_from_slice(&bh);
                        }
                        if dh.len() == 32 {
                            delegate.copy_from_slice(&dh);
                        }
                        action.loan_commitment = Some(LoanCommitmentV11 {
                            borrower_nft_hash: borrower,
                            delegate_nft_hash: delegate,
                            principal: principal as u16,
                            annual_interest_rate_bp: interest_rate as u16,
                            timestamp: loan_ts as u64,
                        });
                    }
                    if action.collateral_sats.is_none()
                        && matches!(
                            action.action_type,
                            MoriaV11ActionType::Repay
                                | MoriaV11ActionType::Redeem
                                | MoriaV11ActionType::Liquidate
                        )
                    {
                        action.collateral_sats = Some(collateral as u64);
                    }
                    looked_up_borrower = Some(bh);
                    looked_up_delegate = Some(dh);
                    delete_loan_utxo(pool, spent_txid, *spent_vout).await?;
                }
            }

            // Create / replace continuing loan UTXO.
            if let Some(output_idx) = action.loan_output_index {
                if let Some(commitment) = action
                    .new_loan_commitment
                    .as_ref()
                    .or(action.loan_commitment.as_ref())
                {
                    insert_loan_utxo(
                        pool,
                        &txid,
                        output_idx,
                        commitment,
                        action.collateral_sats.unwrap_or(0),
                        blockhash,
                    )
                    .await?;
                    // Policy lives on the allowance, revealed at first spend.
                }
            }

            // Allowance deposit on borrow (parser: optional MUSD at out 8/9).
            if let Some(dep) = &action.allowance_deposit {
                if let Some(c) = action
                    .loan_commitment
                    .as_ref()
                    .or(action.new_loan_commitment.as_ref())
                {
                    let verified = verified_borrow_hint_policy(tx, token_ids, c);
                    let fee_sats = verified.as_ref().map(|(_, f)| *f as i64);

                    insert_allowance_utxo(
                        pool,
                        &txid,
                        dep.output_index,
                        &c.borrower_nft_hash,
                        &c.delegate_nft_hash,
                        &dep.locking_bytecode,
                        dep.token_amount,
                        dep.sats,
                        blockhash,
                        verified.as_ref().map(|(p, _)| p),
                        fee_sats,
                    )
                    .await?;
                }
            }

            // Crank: spend prior allowance + insert the purse continuation
            // (not same-index as the METHOD_CRANK input).
            if let Some(info) = &action.crank_allowance {
                let cont_vout = tx
                    .output
                    .iter()
                    .enumerate()
                    .find(|(_, o)| o.script_pubkey.as_bytes() == info.locking_bytecode.as_slice())
                    .map(|(i, _)| i as u32)
                    .unwrap_or(info.io_index);
                if let Some(inp) = tx.input.get(info.io_index as usize) {
                    let prev = &inp.previous_output;
                    if let Some(spent) = lookup_allowance_utxo(pool, &prev.txid, prev.vout).await? {
                        delete_allowance_utxo(pool, &prev.txid, prev.vout).await?;
                        handled_allowance_spends.push((prev.txid, prev.vout));
                        insert_allowance_utxo(
                            pool,
                            &txid,
                            cont_vout,
                            &spent.owner_hash,
                            &spent.delegate_hash,
                            &info.locking_bytecode,
                            info.output_token_amount,
                            info.output_sats,
                            blockhash,
                            spent.policy.as_ref(),
                            spent.fee_sats,
                        )
                        .await?;
                    } else if let Some(c) = action
                        .new_loan_commitment
                        .as_ref()
                        .or(action.loan_commitment.as_ref())
                    {
                        // First spend of an unregistered allowance — classify now.
                        // Policy/fee stay null until a verified borrow hint (or a
                        // later spend of a row that already had them).
                        insert_allowance_utxo(
                            pool,
                            &txid,
                            cont_vout,
                            &c.borrower_nft_hash,
                            &c.delegate_nft_hash,
                            &info.locking_bytecode,
                            info.output_token_amount,
                            info.output_sats,
                            blockhash,
                            None,
                            None,
                        )
                        .await?;
                    } else if let (Some(owner), Some(delegate)) =
                        (&looked_up_borrower, &looked_up_delegate)
                    {
                        insert_allowance_utxo(
                            pool,
                            &txid,
                            cont_vout,
                            owner,
                            delegate,
                            &info.locking_bytecode,
                            info.output_token_amount,
                            info.output_sats,
                            blockhash,
                            None,
                            None,
                        )
                        .await?;
                    }
                }
            }

            // AllowanceClose: look up owner before deleting the spent UTXO.
            if let Some(close) = &action.allowance_close {
                if let Some(inp) = tx.input.get(close.input_index as usize) {
                    let prev = &inp.previous_output;
                    if let Some(spent) = lookup_allowance_utxo(pool, &prev.txid, prev.vout).await? {
                        looked_up_borrower = Some(spent.owner_hash);
                        looked_up_delegate = Some(spent.delegate_hash);
                        delete_allowance_utxo(pool, &prev.txid, prev.vout).await?;
                        handled_allowance_spends.push((prev.txid, prev.vout));
                    }
                }
            }

            debug!(
                "moria_v11: {} {} (borrower: {})",
                action_type_to_str(action.action_type),
                txid,
                action
                    .loan_commitment
                    .as_ref()
                    .or(action.new_loan_commitment.as_ref())
                    .map(|c| hex::encode(c.borrower_nft_hash))
                    .or_else(|| looked_up_borrower.as_ref().map(hex::encode))
                    .unwrap_or_else(|| "n/a".to_string()),
            );

            insert_action(
                pool,
                &txid,
                blockhash,
                mtp,
                None,
                &action,
                looked_up_borrower.as_deref(),
                looked_up_delegate.as_deref(),
            )
            .await?;
            count += 1;
        }

        // Remove any remaining spent known-allowance UTXOs (e.g. closed without
        // parser match, or reorg-safe cleanup of pure spends).
        for inp in &tx.input {
            let prev = &inp.previous_output;
            if handled_allowance_spends
                .iter()
                .any(|(t, v)| t == &prev.txid && *v == prev.vout)
            {
                continue;
            }
            if lookup_allowance_utxo(pool, &prev.txid, prev.vout)
                .await?
                .is_some()
            {
                delete_allowance_utxo(pool, &prev.txid, prev.vout).await?;
            }
        }
    }

    Ok(count)
}

pub async fn delete_entries_for_block(pool: &SqlitePool, blockhash: &BlockHash) -> Result<usize> {
    sqlx::query("DELETE FROM moria_v11_loan_utxo WHERE blockhash = ?")
        .bind(blockhash.to_blob())
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!("failed to delete v11 loan utxos for block: {}", e))?;

    sqlx::query("DELETE FROM moria_v11_allowance_utxo WHERE blockhash = ?")
        .bind(blockhash.to_blob())
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!("failed to delete v11 allowance utxos for block: {}", e))?;

    sqlx::query("DELETE FROM moria_v11_bp_threshold WHERE blockhash = ?")
        .bind(blockhash.to_blob())
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!("failed to delete v11 bp thresholds for block: {}", e))?;

    let r = sqlx::query("DELETE FROM moria_v11_action WHERE blockhash = ?")
        .bind(blockhash.to_blob())
        .execute(pool)
        .await
        .map_err(|e| {
            anyhow::anyhow!(
                "failed to delete moria_v11_action for block {}: {}",
                blockhash,
                e
            )
        })?;

    let staking_deleted = staking::delete_entries_for_block(pool, blockhash).await?;

    Ok(r.rows_affected() as usize + staking_deleted)
}

pub async fn has_entry(pool: &SqlitePool, txid: &Txid) -> Result<bool> {
    let row: Option<(i64,)> =
        sqlx::query_as("SELECT 1 FROM moria_v11_action WHERE txid = ? LIMIT 1")
            .bind(txid.to_blob())
            .fetch_optional(pool)
            .await?;
    Ok(row.is_some())
}

/// Txids currently stored under the mempool sentinel (`BlockHash::all_zeros`).
pub async fn get_unconfirmed_txids(pool: &SqlitePool) -> Result<Vec<Txid>> {
    let zero = BlockHash::all_zeros().to_blob();
    let rows = sqlx::query(
        "SELECT txid FROM moria_v11_action WHERE blockhash = ?
         UNION
         SELECT txid FROM moria_v11_loan_utxo WHERE blockhash = ?
         UNION
         SELECT txid FROM moria_v11_allowance_utxo WHERE blockhash = ?
         UNION
         SELECT txid FROM moria_v11_bp_threshold WHERE blockhash = ?",
    )
    .bind(&zero)
    .bind(&zero)
    .bind(&zero)
    .bind(&zero)
    .fetch_all(pool)
    .await?;
    let mut out = Vec::new();
    for row in rows {
        let blob: Vec<u8> = row.get("txid");
        if blob.len() == 32 {
            let mut arr = [0u8; 32];
            arr.copy_from_slice(&blob);
            out.push(Txid::from_byte_array(arr));
        }
    }
    Ok(out)
}

/// Drop a mempool-only row set (evicted / replaced). Confirmed rows stay.
pub async fn delete_unconfirmed_tx(pool: &SqlitePool, txid: &Txid) -> Result<usize> {
    let zero = BlockHash::all_zeros().to_blob();
    let id = txid.to_blob();
    let mut n = 0usize;
    for table in [
        "moria_v11_loan_utxo",
        "moria_v11_allowance_utxo",
        "moria_v11_bp_threshold",
        "moria_v11_action",
    ] {
        let sql = format!("DELETE FROM {table} WHERE txid = ? AND blockhash = ?");
        let r = sqlx::query(&sql)
            .bind(&id)
            .bind(&zero)
            .execute(pool)
            .await
            .map_err(|e| anyhow::anyhow!("failed to delete unconfirmed {table}: {e}"))?;
        n += r.rows_affected() as usize;
    }
    Ok(n)
}

pub async fn clear_mempool(pool: &SqlitePool) -> Result<usize> {
    let zero = BlockHash::all_zeros().to_blob();
    sqlx::query("DELETE FROM moria_v11_loan_utxo WHERE blockhash = ?")
        .bind(&zero)
        .execute(pool)
        .await?;
    sqlx::query("DELETE FROM moria_v11_allowance_utxo WHERE blockhash = ?")
        .bind(&zero)
        .execute(pool)
        .await?;
    sqlx::query("DELETE FROM moria_v11_bp_threshold WHERE blockhash = ?")
        .bind(&zero)
        .execute(pool)
        .await?;
    let r = sqlx::query("DELETE FROM moria_v11_action WHERE blockhash = ?")
        .bind(&zero)
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!("failed to clear v11 mempool entries: {}", e))?;
    Ok(r.rows_affected() as usize)
}