Transaction Processing

pub fn execute_transaction<T: ProcessingContext>(
    tx: &TxEnvelope,
    sender: Address,
    bundle_state: &mut BundleStateManager,
    state: &mut T,
    block_timestamp: u64,
) -> Result<ExecutionResult>

use core_lane::{execute_transaction, CoreLaneStateForLib};
use core_lane::{StateManager, BundleStateManager};
use alloy_consensus::TxEnvelope;
use alloy_rlp::Decodable;

let mut state = CoreLaneStateForLib::new(
    StateManager::new(),
    bitcoin_client_read,
    bitcoin_client_write,
    bitcoin::Network::Regtest
);

let mut bundle = BundleStateManager::new();
let tx_bytes = hex::decode("...")?;
let tx = TxEnvelope::decode(&mut tx_bytes.as_slice())?;
let sender = tx.recover_signer()?;

let result = execute_transaction(
    &tx,
    sender,
    &mut bundle,
    &mut state,
    1234567890
)?;

if result.success {
    state.state_manager_mut().apply_changes(bundle);
}

pub fn get_transaction_input_bytes(tx: &TxEnvelope) -> Vec<u8>

pub fn get_transaction_nonce(tx: &TxEnvelope) -> u64

pub trait ProcessingContext {
    fn state_manager(&self) -> &StateManager;
    fn state_manager_mut(&mut self) -> &mut StateManager;
    fn bitcoin_client_read(&self) -> Option<Arc<dyn BitcoinRpcReadClient>>;
    fn bitcoin_network(&self) -> bitcoin::Network;
    fn handle_cmio_query(
        &mut self,
        message: CmioMessage,
        current_intent_id: Option<B256>,
    ) -> Option<CmioMessage>;
}

pub struct ExecutionResult {
    pub success: bool,
    pub gas_used: U256,
    pub gas_refund: U256,
    pub output: Bytes,
    pub logs: Vec<String>,
    pub error: Option<String>,
}

use core_lane::{CoreLaneAddresses, Address};

let exit_marketplace = CoreLaneAddresses::exit_marketplace();
let burn_address = CoreLaneAddresses::burn();

// Check if transaction is to exit marketplace
if tx.to() == Some(exit_marketplace) {
    // Handle intent operation
}

let tx_nonce = get_transaction_nonce(tx);
let expected_nonce = bundle_state.get_nonce(state.state_manager(), sender);

if U256::from(tx_nonce) != expected_nonce {
    return Ok(ExecutionResult {
        success: false,
        error: Some(format!(
            "Invalid nonce: expected {}, got {}",
            expected_nonce, tx_nonce
        )),
        // ...
    });
}

if bundle_state.get_balance(state.state_manager(), sender) < value {
    return Ok(ExecutionResult {
        success: false,
        error: Some("Insufficient balance".to_string()),
        // ...
    });
}