newton-core 0.4.16

use alloy::{primitives::Address, providers::Provider, sol};

use crate::newton_prover_task_manager::NewtonProverTaskManager;

sol! {
    #[sol(rpc)]
    interface ITaskResponseHandlerVerifier {
        function certificateVerifier() external view returns (address);
    }
}

/// Resolved destination-chain verifier wiring derived from TaskManager.
#[derive(Debug, Clone, Copy)]
pub struct ResolvedDestinationVerifier {
    /// task response handler currently set on task manager
    pub task_response_handler: Address,
    /// certificate verifier currently set on task response handler
    pub certificate_verifier: Address,
    /// source chain AVS service manager read from task manager
    pub source_chain_avs: Address,
}

/// Resolve active destination verification wiring from task manager state.
pub async fn resolve_destination_verifier<P>(
    task_manager_addr: Address,
    provider: P,
) -> Result<ResolvedDestinationVerifier, eyre::Error>
where
    P: Provider + Clone,
{
    let task_manager = NewtonProverTaskManager::new(task_manager_addr, provider.clone());
    let task_response_handler = task_manager
        .taskResponseHandler()
        .call()
        .await
        .map_err(|e| eyre::eyre!("failed to get task response handler address: {:?}", e))?;

    let task_response_handler_contract = ITaskResponseHandlerVerifier::new(task_response_handler, provider.clone());
    let certificate_verifier = task_response_handler_contract
        .certificateVerifier()
        .call()
        .await
        .map_err(|e| eyre::eyre!("failed to get certificate verifier from task response handler: {:?}", e))?;

    let source_chain_avs = task_manager
        .serviceManager()
        .call()
        .await
        .map_err(|e| eyre::eyre!("failed to get source chain avs address: {:?}", e))?;

    Ok(ResolvedDestinationVerifier {
        task_response_handler,
        certificate_verifier,
        source_chain_avs,
    })
}