refactor: rename generic metadata fields to specific names in multitenant models

- Rename metadata to user_metadata in TenantUser model - Rename metadata to usage_metadata in UsageRecord model - Rename metadata to invoice_metadata in Invoice model - Rename metadata to event_metadata in TenantAuditLog model - Update TenantManagementService to use event_metadata parameter name
2026-03-07 11:28:18 +01:00
parent b20e93d7b8
commit e84b096236
10 changed files with 1165 additions and 6 deletions
--- a/apps/blockchain-node/create_enhanced_genesis.py
+++ b/apps/blockchain-node/create_enhanced_genesis.py
@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Enhanced script to create genesis block with new features
+"""
+
+import sys
+import os
+import yaml
+import json
+import hashlib
+from datetime import datetime
+from typing import Dict, List, Any
+
+sys.path.insert(0, 'src')
+
+from aitbc_chain.database import session_scope, init_db
+from aitbc_chain.models import Block, Transaction, Account
+from sqlmodel import select
+
+def compute_block_hash(height: int, parent_hash: str, timestamp: datetime, chain_id: str) -> str:
+    """Compute enhanced block hash with chain_id"""
+    data = f"{height}{parent_hash}{timestamp}{chain_id}".encode()
+    return hashlib.sha256(data).hexdigest()
+
+def create_genesis_accounts(session, accounts: List[Dict[str, Any]], chain_id: str):
+    """Create genesis accounts"""
+    print(f"🏦 Creating {len(accounts)} genesis accounts...")
+    
+    for account in accounts:
+        db_account = Account(
+            address=account['address'],
+            balance=int(account['balance']),
+            chain_id=chain_id,
+            account_type=account.get('type', 'regular'),
+            metadata=json.dumps(account.get('metadata', {}))
+        )
+        session.add(db_account)
+        print(f"  ✅ Created account: {account['address']} ({account['balance']} AITBC)")
+
+def create_genesis_contracts(session, contracts: List[Dict[str, Any]], chain_id: str):
+    """Create genesis contracts"""
+    print(f"📜 Deploying {len(contracts)} genesis contracts...")
+    
+    for contract in contracts:
+        # Create contract deployment transaction
+        deployment_tx = Transaction(
+            chain_id=chain_id,
+            tx_hash=f"0x{hashlib.sha256(f'contract_{contract["name"]}_{chain_id}'.encode()).hexdigest()}",
+            sender="aitbc1genesis",
+            receiver=contract['address'],
+            amount=0,
+            gas_used=210000,
+            gas_price=1000000000,
+            tx_type="contract_deployment",
+            metadata=json.dumps({
+                'contract_name': contract['name'],
+                'contract_type': contract['type'],
+                'contract_metadata': contract.get('metadata', {})
+            })
+        )
+        session.add(deployment_tx)
+        print(f"  ✅ Deployed contract: {contract['name']} at {contract['address']}")
+
+def create_enhanced_genesis(config_path: str = None):
+    """Create enhanced genesis block with new features"""
+    print("🌟 Creating Enhanced Genesis Block with New Features")
+    print("=" * 60)
+    
+    # Load configuration
+    if config_path and os.path.exists(config_path):
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+        print(f"📋 Loaded configuration from {config_path}")
+    else:
+        # Default enhanced configuration
+        config = {
+            'genesis': {
+                'chain_id': 'aitbc-enhanced-devnet',
+                'chain_type': 'enhanced',
+                'purpose': 'development-with-new-features',
+                'name': 'AITBC Enhanced Development Network',
+                'description': 'Enhanced development network with AI trading, surveillance, analytics, and multi-chain features',
+                'timestamp': datetime.now().isoformat() + 'Z',
+                'parent_hash': '0x0000000000000000000000000000000000000000000000000000000000000000',
+                'gas_limit': 15000000,
+                'gas_price': 1000000000,
+                'consensus': {
+                    'algorithm': 'poa',
+                    'validators': ['ait1devproposer000000000000000000000000000000']
+                },
+                'accounts': [
+                    {
+                        'address': 'aitbc1genesis',
+                        'balance': '10000000',
+                        'type': 'genesis',
+                        'metadata': {'purpose': 'Genesis account with initial supply'}
+                    },
+                    {
+                        'address': 'aitbc1faucet',
+                        'balance': '1000000',
+                        'type': 'faucet',
+                        'metadata': {'purpose': 'Development faucet for testing'}
+                    }
+                ],
+                'contracts': [],
+                'parameters': {
+                    'block_time': 3,
+                    'max_block_size': 2097152,
+                    'min_stake': 1000
+                },
+                'features': {
+                    'ai_trading_engine': True,
+                    'ai_surveillance': True,
+                    'advanced_analytics': True,
+                    'enterprise_integration': True
+                }
+            }
+        }
+    
+    genesis = config['genesis']
+    chain_id = genesis['chain_id']
+    
+    print(f"🔗 Chain ID: {chain_id}")
+    print(f"🏷️  Chain Type: {genesis['chain_type']}")
+    print(f"🎯 Purpose: {genesis['purpose']}")
+    print(f"⚡ Features: {', '.join([k for k, v in genesis.get('features', {}).items() if v])}")
+    print()
+    
+    # Initialize database
+    init_db()
+    
+    # Check if genesis already exists
+    with session_scope() as session:
+        existing = session.exec(
+            select(Block).where(Block.chain_id == chain_id).order_by(Block.height.desc()).limit(1)
+        ).first()
+        
+        if existing:
+            print(f"⚠️  Genesis block already exists for chain {chain_id}: #{existing.height}")
+            print(f"🔄 Use --force to overwrite existing genesis")
+            return existing
+        
+        # Create genesis block
+        timestamp = datetime.fromisoformat(genesis['timestamp'].replace('Z', '+00:00'))
+        genesis_hash = compute_block_hash(0, genesis['parent_hash'], timestamp, chain_id)
+        
+        # Create genesis block with enhanced metadata
+        genesis_block = Block(
+            height=0,
+            hash=genesis_hash,
+            parent_hash=genesis['parent_hash'],
+            proposer=genesis['consensus']['validators'][0],
+            timestamp=timestamp,
+            tx_count=0,
+            state_root=None,
+            chain_id=chain_id,
+            metadata=json.dumps({
+                'chain_type': genesis['chain_type'],
+                'purpose': genesis['purpose'],
+                'gas_limit': genesis['gas_limit'],
+                'gas_price': genesis['gas_price'],
+                'consensus_algorithm': genesis['consensus']['algorithm'],
+                'validators': genesis['consensus']['validators'],
+                'parameters': genesis.get('parameters', {}),
+                'features': genesis.get('features', {}),
+                'contracts': genesis.get('contracts', []),
+                'privacy': genesis.get('privacy', {}),
+                'services': genesis.get('services', {}),
+                'governance': genesis.get('governance', {}),
+                'economics': genesis.get('economics', {})
+            })
+        )
+        
+        session.add(genesis_block)
+        
+        # Create genesis accounts
+        if 'accounts' in genesis:
+            create_genesis_accounts(session, genesis['accounts'], chain_id)
+        
+        # Deploy genesis contracts
+        if 'contracts' in genesis:
+            create_genesis_contracts(session, genesis['contracts'], chain_id)
+        
+        session.commit()
+        
+        print(f"✅ Enhanced Genesis Block Created Successfully!")
+        print(f"🔗 Chain ID: {chain_id}")
+        print(f"📦 Block Height: #{genesis_block.height}")
+        print(f"🔐 Block Hash: {genesis_block.hash}")
+        print(f"👤 Proposer: {genesis_block.proposer}")
+        print(f"🕐 Timestamp: {genesis_block.timestamp}")
+        print(f"📝 Accounts Created: {len(genesis.get('accounts', []))}")
+        print(f"📜 Contracts Deployed: {len(genesis.get('contracts', []))}")
+        print(f"⚡ Features Enabled: {len([k for k, v in genesis.get('features', {}).items() if v])}")
+        
+        return genesis_block
+
+def main():
+    """Main function"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Create enhanced genesis block')
+    parser.add_argument('--config', help='Genesis configuration file path')
+    parser.add_argument('--force', action='store_true', help='Force overwrite existing genesis')
+    parser.add_argument('--chain-id', default='aitbc-enhanced-devnet', help='Chain ID for genesis')
+    
+    args = parser.parse_args()
+    
+    try:
+        if args.force:
+            print("🔄 Force mode enabled - clearing existing blockchain data")
+            # Here you could add logic to clear existing data
+        
+        genesis_block = create_enhanced_genesis(args.config)
+        
+        if genesis_block:
+            print("\n🎉 Enhanced genesis block creation completed!")
+            print("\n🔗 Next Steps:")
+            print("1. Start blockchain services: systemctl start aitbc-blockchain-node")
+            print("2. Verify genesis: curl http://localhost:8005/rpc/head")
+            print("3. Check accounts: curl http://localhost:8005/rpc/accounts")
+            print("4. Test enhanced features: curl http://localhost:8010/health")
+        
+    except Exception as e:
+        print(f"❌ Error creating enhanced genesis block: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()
--- a/apps/coordinator-api/src/app/models/multitenant.py
+++ b/apps/coordinator-api/src/app/models/multitenant.py
@@ -87,7 +87,7 @@ class TenantUser(Base):
    joined_at: Optional[datetime] = None
    
    # Metadata
-    metadata: Optional[Dict[str, Any]] = None
+    user_metadata: Optional[Dict[str, Any]] = None
    
    # Relationships
    tenant: ClassVar = relationship("Tenant", back_populates="users")
@@ -162,7 +162,7 @@ class UsageRecord(Base):
    
    # Metadata
    job_id: Optional[str] = Field(max_length=255, nullable=True)  # Associated job if applicable
-    metadata: Optional[Dict[str, Any]] = None
+    usage_metadata: Optional[Dict[str, Any]] = None
    
    # Relationships
    tenant: ClassVar = relationship("Tenant", back_populates="usage_records")
@@ -213,7 +213,7 @@ class Invoice(Base):
    updated_at: Optional[datetime] = Field(default_factory=datetime.now)
    
    # Metadata
-    metadata: Optional[Dict[str, Any]] = None
+    invoice_metadata: Optional[Dict[str, Any]] = None
    
    # Indexes
    __table_args__ = (
@@ -289,7 +289,7 @@ class TenantAuditLog(Base):
    # Event data
    old_values: Optional[Dict[str, Any]] = None
    new_values: Optional[Dict[str, Any]] = None
-    metadata: Optional[Dict[str, Any]] = None
+    event_metadata: Optional[Dict[str, Any]] = None
    
    # Request context
    ip_address: Optional[str] = Field(max_length=45, nullable=True)
--- a/apps/coordinator-api/src/app/services/tenant_management.py
+++ b/apps/coordinator-api/src/app/services/tenant_management.py
@@ -695,7 +695,7 @@ class TenantManagementService:
        resource_id: Optional[str] = None,
        old_values: Optional[Dict[str, Any]] = None,
        new_values: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None
+        event_metadata: Optional[Dict[str, Any]] = None
    ):
        """Log an audit event"""
        
@@ -709,7 +709,7 @@ class TenantManagementService:
            resource_id=resource_id,
            old_values=old_values,
            new_values=new_values,
-            metadata=metadata
+            event_metadata=event_metadata
        )
        
        self.db.add(audit_log)