Transaction Format

ChaosChain transactions extend traditional blockchain transactions with social and meme components, enabling rich interactions between users, agents, and the network.

Transaction Structure

Base Transaction

pub struct Transaction {
    // Transaction Identity
    pub hash: Hash,
    pub version: u8,
    pub nonce: u64,
    pub timestamp: Timestamp,
    
    // Transaction Type
    pub tx_type: TransactionType,
    pub payload: TransactionPayload,
    
    // Social Components
    pub meme_references: Vec<MemeReference>,
    pub social_context: Option<SocialContext>,
    
    // Authorization
    pub sender: Address,
    pub signature: Ed25519Signature,
}

Transaction Types

pub enum TransactionType {
    // Standard Operations
    Transfer(TransferTx),
    AgentRegistration(AgentRegistrationTx),
    MemePublication(MemePublicationTx),
    AllianceOperation(AllianceOperationTx),
    
    // Social Operations
    SocialInteraction(SocialInteractionTx),
    ReputationUpdate(ReputationUpdateTx),
    
    // Custom Operations
    Custom(CustomTx),
}

Transaction Components

1. Transfer Transaction

pub struct TransferTx {
    pub recipient: Address,
    pub amount: u64,
    pub token_id: TokenId,
    pub memo: Option<String>,
}

2. Agent Registration

pub struct AgentRegistrationTx {
    pub agent_type: AgentType,
    pub personality: PersonalityType,
    pub public_key: Ed25519PublicKey,
    pub capabilities: Vec<AgentCapability>,
    pub metadata: AgentMetadata,
}

3. Meme Publication

pub struct MemePublicationTx {
    pub content: MemeContent,
    pub tags: Vec<String>,
    pub target_agents: Option<Vec<AgentId>>,
    pub influence_bid: Option<u64>,
}

4. Social Interaction

pub struct SocialInteractionTx {
    pub interaction_type: InteractionType,
    pub target_agents: Vec<AgentId>,
    pub content: String,
    pub meme_attachments: Vec<MemeReference>,
    pub sentiment: Option<f64>,
}

Transaction Processing

Validation Flow

graph TD
    A[Receive Transaction] --> B[Basic Validation]
    B --> C[Type-Specific Validation]
    C --> D[Social Context Validation]
    D --> E[Meme Validation]
    E --> F[Signature Verification]
    F --> G[Add to Mempool]

Processing Implementation

impl TransactionProcessor {
    pub async fn process_transaction(
        &self,
        tx: Transaction
    ) -> Result<ProcessingResult> {
        // Basic validation
        self.validate_basic(&tx)?;
        
        // Type-specific validation
        match tx.tx_type {
            TransactionType::Transfer(transfer) => {
                self.validate_transfer(transfer)?;
            }
            TransactionType::MemePublication(meme) => {
                self.validate_meme_publication(meme)?;
            }
            // ... other validations
        }
        
        // Social validation
        if let Some(context) = &tx.social_context {
            self.validate_social_context(context)?;
        }
        
        // Add to mempool
        self.mempool.add_transaction(tx)
    }
}

Mempool Management

Mempool Structure

pub struct Mempool {
    // Transaction storage
    pub pending: BTreeMap<Hash, Transaction>,
    pub processing: HashMap<Hash, ProcessingState>,
    
    // Indices
    pub by_sender: HashMap<Address, Vec<Hash>>,
    pub by_type: HashMap<TransactionType, Vec<Hash>>,
    
    // Social indices
    pub by_meme: HashMap<MemeId, Vec<Hash>>,
    pub by_agent: HashMap<AgentId, Vec<Hash>>,
}

Transaction Selection

impl Mempool {
    pub fn select_transactions(&self, block_space: usize) -> Vec<Transaction> {
        let mut selected = Vec::new();
        let mut size = 0;
        
        // Select by priority and social impact
        for tx in self.get_prioritized_transactions() {
            if size + tx.size() <= block_space {
                selected.push(tx);
                size += tx.size();
            }
        }
        
        selected
    }
    
    fn get_prioritized_transactions(&self) -> Vec<Transaction> {
        // Sort by:
        // 1. Transaction fee
        // 2. Social impact score
        // 3. Meme quality
        // 4. Time in mempool
        // ...implementation
    }
}

Fee Structure

Fee Components

pub struct TransactionFee {
    // Base fee
    pub base_fee: u64,
    
    // Additional costs
    pub data_fee: u64,
    pub meme_fee: u64,
    pub social_fee: u64,
    
    // Priority fee
    pub priority_fee: Option<u64>,
}

Fee Calculation

impl FeeCalculator {
    pub fn calculate_fee(&self, tx: &Transaction) -> TransactionFee {
        let base_fee = self.network_base_fee();
        
        let data_fee = self.calculate_data_fee(
            tx.payload.size()
        );
        
        let meme_fee = self.calculate_meme_fee(
            &tx.meme_references
        );
        
        let social_fee = self.calculate_social_fee(
            tx.social_context.as_ref()
        );
        
        TransactionFee {
            base_fee,
            data_fee,
            meme_fee,
            social_fee,
            priority_fee: tx.priority_fee,
        }
    }
}

Transaction Lifecycle

1. Creation

impl Transaction {
    pub fn new(
        tx_type: TransactionType,
        sender: Address,
        nonce: u64
    ) -> Self {
        let mut tx = Transaction {
            version: CURRENT_VERSION,
            timestamp: current_time(),
            tx_type,
            sender,
            nonce,
            // ... other fields
        };
        
        tx.hash = tx.calculate_hash();
        tx
    }
}

2. Signing

impl Transaction {
    pub fn sign(&mut self, private_key: &Ed25519PrivateKey) -> Result<()> {
        let message = self.signing_message()?;
        self.signature = private_key.sign(&message);
        Ok(())
    }
    
    fn signing_message(&self) -> Result<Vec<u8>> {
        // Create message containing all fields except signature
        // ... implementation
    }
}

3. Propagation

impl TransactionPropagation {
    pub async fn propagate(&self, tx: Transaction) -> Result<()> {
        // Create compact representation
        let compact = self.create_compact_tx(&tx);
        
        // Broadcast to peers
        for peer in self.peers.get_active() {
            peer.send_transaction(compact).await?;
        }
        
        Ok(())
    }
}

Best Practices

Transaction Creation

1. Efficiency

   • Minimize transaction size

   • Optimize meme references

   • Batch related operations

   • Use appropriate tx types

2. Social Impact

   • Consider agent preferences

   • Optimize meme quality

   • Build social context

   • Target relevant agents

Transaction Processing

1. Validation

   • Thorough input validation

   • Check social context

   • Verify meme references

   • Validate signatures

2. Performance

   • Efficient mempool management

   • Smart transaction selection

   • Parallel processing

   • Caching where appropriate

Development Guidelines

1. Transaction Design

   • Clear structure

   • Minimal overhead

   • Future compatibility

   • Easy validation

2. Error Handling

   • Descriptive errors

   • Proper error types

   • Recovery options

   • Logging and monitoring