subprotocol.rs

//! Debug subprotocol implementation.
//!
//! This module contains the core subprotocol implementation that integrates
//! with the Strata Anchor State Machine (ASM).

use ssz_derive::{Decode, Encode};
use strata_asm_bridge_msgs::{BridgeIncomingMsg, DispatchWithdrawalPayload};
use strata_asm_common::{
    AsmError, AsmLogEntry, MsgRelayer, NullMsg, Subprotocol, SubprotocolId, TxInputRef,
    VerifiedAuxData, logging,
};
use strata_identifiers::L1BlockCommitment;

use crate::{
    constants::DEBUG_SUBPROTOCOL_ID,
    txs::{ParsedDebugTx, parse_debug_tx},
};

/// Debug subprotocol implementation.
///
/// This subprotocol provides testing capabilities by processing special
/// L1 transactions that inject mock data into the ASM.
#[derive(Copy, Clone, Debug)]
pub struct DebugSubproto;

#[derive(Copy, Clone, Debug, Default, Encode, Decode)]
pub struct DebugState;

impl Subprotocol for DebugSubproto {
    const ID: SubprotocolId = DEBUG_SUBPROTOCOL_ID;

    type Msg = NullMsg<DEBUG_SUBPROTOCOL_ID>;
    type InitConfig = ();
    type State = DebugState;

    fn init(_config: &Self::InitConfig) -> Self::State {
        logging::info!("Initializing debug subprotocol state");
        DebugState
    }

    fn process_txs(
        _state: &mut Self::State,
        txs: &[TxInputRef<'_>],
        _l1ref: &L1BlockCommitment,
        _verified_aux_data: &VerifiedAuxData,
        relayer: &mut impl MsgRelayer,
    ) {
        for tx_ref in txs {
            logging::debug!(
                tx_type = tx_ref.tag().tx_type(),
                "Processing debug transaction"
            );

            match parse_debug_tx(tx_ref) {
                Ok(parsed_tx) => {
                    if let Err(e) = process_parsed_debug_tx(parsed_tx, relayer) {
                        logging::warn!("Failed to process debug transaction: {}", e);
                    }
                }
                Err(e) => {
                    logging::warn!("Failed to parse debug transaction: {}", e);
                }
            }
        }
    }

    fn process_msgs(_state: &mut Self::State, _msgs: &[Self::Msg], _l1ref: &L1BlockCommitment) {
        // No messages to process for the debug subprotocol
    }
}

/// Process a parsed debug transaction.
fn process_parsed_debug_tx(
    parsed_tx: ParsedDebugTx,
    relayer: &mut impl MsgRelayer,
) -> Result<(), AsmError> {
    match parsed_tx {
        ParsedDebugTx::MockAsmLog(log_info) => {
            logging::info!("Processing ASM log injection");

            // Create log entry directly from raw bytes
            // The log_info contains the raw bytes that represent the log
            let log_entry = match AsmLogEntry::from_raw(log_info.bytes) {
                Ok(entry) => entry,
                Err(err) => {
                    logging::warn!("Skipping ASM log injection: {err}");
                    return Ok(());
                }
            };

            relayer.emit_log(log_entry);
            logging::info!("Successfully emitted ASM log");
        }

        ParsedDebugTx::MockWithdrawIntent((output, selected_operator)) => {
            logging::info!(amount = output.amt.to_sat(), "Processing mock withdrawal");

            let bridge_msg = BridgeIncomingMsg::DispatchWithdrawal(DispatchWithdrawalPayload {
                output,
                selected_operator,
            });
            relayer.relay_msg(&bridge_msg);

            logging::info!("Successfully sent mock withdrawal intent to bridge");
        }
    }

    Ok(())
}