# Module Consensus - CS None ## Overview CS None (Consensus None) module provides a simple pass-through consensus mechanism for development and testing environments. This module bypasses traditional consensus validation, allowing direct block acceptance for rapid development, testing scenarios, and controlled environments where consensus overhead is not required. *See also: [[Module Consensus|Consensus Overview]], [[Module Consensus - DAG PoA|DAG Proof of Authority]], [[Module Consensus - ESBOCS|ESBOCS Consensus]], [[ETC/Architecture Overview|System Architecture]]* *Based on: `dap_chain_cs_none.h`, `dap_chain_cs_none.c`* ## Document Structure - [[#Overview|Overview]] - [[#Module Structures|Module Structures]] - [[#dap_chain_cs_none_t|dap_chain_cs_none_t - CS None Consensus Structure]] - [[#dap_chain_cs_none_config_t|dap_chain_cs_none_config_t - Configuration Parameters]] - [[#dap_chain_cs_none_block_t|dap_chain_cs_none_block_t - Block Processing]] - [[#dap_chain_cs_none_stats_t|dap_chain_cs_none_stats_t - Performance Statistics]] - [[#Module Functions|Module Functions]] - [[#Initialization Functions|Consensus Initialization and Setup]] - [[#Block Processing Functions|Block Creation and Acceptance]] - [[#Transaction Functions|Transaction Processing]] - [[#Statistics Functions|Performance Monitoring]] - [[#Error Codes|Error Codes]] - [[#Typical Examples|Typical Examples]] ## Module Structures ### dap_chain_cs_none_t Main CS None consensus structure managing the no-validation consensus mechanism. ```c typedef struct dap_chain_cs_none { struct { dap_chain_t *chain; // Associated blockchain dap_chain_cs_none_config_t *config; // Consensus configuration bool is_active; // Consensus operational status uint64_t blocks_processed; // Total blocks processed counter uint64_t transactions_processed; // Total transactions processed counter dap_time_t start_time; // Consensus start timestamp } pub; struct { dap_chain_cs_none_stats_t *stats; // Performance statistics pthread_mutex_t consensus_mutex; // Thread synchronization mutex uint64_t last_block_time; // Last block processing timestamp bool auto_accept_enabled; // Automatic acceptance flag uint32_t processing_delay_ms; // Artificial processing delay dap_list_t *pending_operations; // Pending operations queue } priv; } dap_chain_cs_none_t; ``` **Public Fields:** - `chain` - Reference to the blockchain using this consensus - `config` - Configuration parameters for consensus operation - `is_active` - Current operational status of the consensus - `blocks_processed` - Counter for total blocks processed - `transactions_processed` - Counter for total transactions processed - `start_time` - Timestamp when consensus was started **Private Fields:** - `stats` - Performance and operational statistics - `consensus_mutex` - Thread-safe operation synchronization - `auto_accept_enabled` - Flag for automatic acceptance mode - `processing_delay_ms` - Configurable delay for testing scenarios ### dap_chain_cs_none_config_t Configuration parameters for CS None consensus operation. ```c typedef struct dap_chain_cs_none_config { struct { bool auto_accept_blocks; // Automatically accept all blocks bool auto_accept_transactions; // Automatically accept all transactions uint32_t block_time_ms; // Target block creation time uint32_t max_block_size; // Maximum block size limit bool enable_logging; // Enable consensus operation logging bool enable_statistics; // Enable performance statistics } pub; struct { uint32_t processing_delay_ms; // Artificial processing delay for testing bool simulate_validation; // Simulate validation process timing uint32_t validation_delay_ms; // Simulated validation delay bool debug_mode; // Enable detailed debug logging uint32_t max_pending_operations; // Maximum pending operations limit } priv; } dap_chain_cs_none_config_t; ``` **Configuration Options:** - `auto_accept_blocks` - Accept all blocks without validation - `auto_accept_transactions` - Accept all transactions without validation - `block_time_ms` - Target time between block creation - `simulate_validation` - Option to simulate validation delays for testing - `debug_mode` - Enable comprehensive debug logging ### dap_chain_cs_none_block_t Block structure for CS None consensus processing. ```c typedef struct dap_chain_cs_none_block { struct { dap_chain_block_t *block; // Standard block structure dap_time_t received_time; // Block received timestamp dap_time_t processed_time; // Block processed timestamp bool is_accepted; // Block acceptance status uint64_t block_number; // Sequential block number uint32_t transaction_count; // Number of transactions in block } pub; struct { uint32_t processing_time_ms; // Processing time in milliseconds bool was_simulated; // Indicates simulated validation dap_chain_cs_none_t *consensus; // Parent consensus reference void *user_data; // User-defined metadata uint32_t flags; // Processing flags } priv; } dap_chain_cs_none_block_t; ``` **Block Processing:** - `block` - Reference to the standard block structure - `received_time` - Timestamp when block was received - `processed_time` - Timestamp when processing completed - `is_accepted` - Whether block was accepted (always true for CS None) - `processing_time_ms` - Time taken to process the block ### dap_chain_cs_none_stats_t Performance and operational statistics for CS None consensus. ```c typedef struct dap_chain_cs_none_stats { struct { uint64_t total_blocks_accepted; // Total blocks accepted uint64_t total_transactions_accepted; // Total transactions accepted uint64_t total_blocks_rejected; // Total blocks rejected (should be 0) uint64_t total_transactions_rejected; // Total transactions rejected (should be 0) double avg_block_processing_time_ms; // Average block processing time double avg_tx_processing_time_ms; // Average transaction processing time uint64_t operations_per_second; // Current operations per second } pub; struct { uint64_t processing_time_total_ms; // Cumulative processing time uint64_t last_reset_time; // Last statistics reset timestamp uint32_t operations_count; // Total operations counter dap_time_t session_start_time; // Statistics session start time bool is_collecting; // Statistics collection status uint64_t peak_ops_per_second; // Peak operations per second recorded } priv; } dap_chain_cs_none_stats_t; ``` ## Module Functions ### Initialization Functions #### `dap_chain_cs_none_new()` Creates a new CS None consensus instance for a blockchain. ```c dap_chain_cs_none_t* dap_chain_cs_none_new(dap_chain_t *a_chain); ``` **Parameters:** - `a_chain` (dap_chain_t*) - Blockchain to attach the consensus **Returns:** - `dap_chain_cs_none_t*` - New CS None consensus instance - `NULL` - Creation failed or invalid parameters **Error Conditions:** - Returns NULL if a_chain is NULL - Returns NULL if memory allocation fails - Returns NULL if mutex initialization fails **Description:** Creates and initializes a new CS None consensus instance with default configuration. #### `dap_chain_cs_none_init()` Initializes CS None consensus with specific configuration parameters. ```c int dap_chain_cs_none_init(dap_chain_cs_none_t *a_consensus, dap_chain_cs_none_config_t *a_config); ``` **Parameters:** - `a_consensus` (dap_chain_cs_none_t*) - Consensus instance to initialize - `a_config` (dap_chain_cs_none_config_t*) - Configuration parameters **Returns:** - `0` - Initialization successful - `-1` - Invalid consensus instance - `-2` - Invalid configuration parameters - `-3` - Statistics initialization failed **Error Conditions:** - Returns -1 if a_consensus is NULL - Returns -2 if a_config contains invalid values - Returns -3 if statistics module initialization fails #### `dap_chain_cs_none_config_default()` Creates default configuration for CS None consensus. ```c dap_chain_cs_none_config_t* dap_chain_cs_none_config_default(void); ``` **Returns:** - `dap_chain_cs_none_config_t*` - Default configuration structure - `NULL` - Memory allocation failed **Description:** Creates a configuration structure with sensible defaults for development use. ### Block Processing Functions #### `dap_chain_cs_none_create_block()` Creates a new block containing specified transactions without validation. ```c dap_chain_block_t* dap_chain_cs_none_create_block(dap_chain_cs_none_t *a_consensus, dap_list_t *a_transactions); ``` **Parameters:** - `a_consensus` (dap_chain_cs_none_t*) - CS None consensus instance - `a_transactions` (dap_list_t*) - List of transactions to include **Returns:** - `dap_chain_block_t*` - Pointer to created block - `NULL` - Block creation failed **Error Conditions:** - Returns NULL if a_consensus is NULL - Returns NULL if memory allocation fails - Returns NULL if transaction list is invalid **Description:** Creates a block immediately without any validation of the included transactions. #### `dap_chain_cs_none_accept_block()` Accepts a block into the chain without validation. ```c int dap_chain_cs_none_accept_block(dap_chain_cs_none_t *a_consensus, dap_chain_block_t *a_block); ``` **Parameters:** - `a_consensus` (dap_chain_cs_none_t*) - CS None consensus instance - `a_block` (dap_chain_block_t*) - Block to accept **Returns:** - `0` - Block accepted successfully - `-1` - Invalid consensus instance - `-2` - Invalid block - `-3` - Processing error **Error Conditions:** - Returns -1 if a_consensus is NULL - Returns -2 if a_block is NULL or corrupted - Returns -3 if block processing fails due to system error **Description:** Accepts the block immediately without any validation checks. #### `dap_chain_cs_none_process_block()` Processes a block through the CS None consensus mechanism. ```c int dap_chain_cs_none_process_block(dap_chain_cs_none_t *a_consensus, dap_chain_block_t *a_block, bool a_update_stats); ``` **Parameters:** - `a_consensus` (dap_chain_cs_none_t*) - CS None consensus instance - `a_block` (dap_chain_block_t*) - Block to process - `a_update_stats` (bool) - Whether to update statistics **Returns:** - `0` - Processing successful - `-1` - Invalid parameters - `-2` - Processing failed ### Transaction Functions #### `dap_chain_cs_none_accept_transaction()` Accepts a transaction without validation. ```c int dap_chain_cs_none_accept_transaction(dap_chain_cs_none_t *a_consensus, dap_chain_datum_tx_t *a_transaction); ``` **Parameters:** - `a_consensus` (dap_chain_cs_none_t*) - CS None consensus instance - `a_transaction` (dap_chain_datum_tx_t*) - Transaction to accept **Returns:** - `0` - Transaction accepted - `-1` - Invalid parameters - `