feat: add marketplace metrics, privacy features, and service registry endpoints

- Add Prometheus metrics for marketplace API throughput and error rates with new dashboard panels
- Implement confidential transaction models with encryption support and access control
- Add key management system with registration, rotation, and audit logging
- Create services and registry routers for service discovery and management
- Integrate ZK proof generation for privacy-preserving receipts
- Add metrics instru

research/consortium/economic_models_research_plan.md

@@ -0,0 +1,737 @@
+# Economic Models Research Plan
+
+## Executive Summary
+
+This research plan explores advanced economic models for blockchain ecosystems, focusing on sustainable tokenomics, dynamic incentive mechanisms, and value capture strategies. The research aims to create economic systems that ensure long-term sustainability, align stakeholder incentives, and enable scalable growth while maintaining decentralization.
+
+## Research Objectives
+
+### Primary Objectives
+1. **Design Sustainable Tokenomics** that ensure long-term value
+2. **Create Dynamic Incentive Models** that adapt to network conditions
+3. **Implement Value Capture Mechanisms** for ecosystem growth
+4. **Develop Economic Simulation Tools** for policy testing
+5. **Establish Economic Governance** for parameter adjustment
+
+### Secondary Objectives
+1. **Reduce Volatility** through stabilization mechanisms
+2. **Enable Fair Distribution** across participants
+3. **Create Economic Resilience** against market shocks
+4. **Support Cross-Chain Economics** for interoperability
+5. **Measure Economic Health** with comprehensive metrics
+
+## Technical Architecture
+
+### Economic Stack
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Application Layer                        │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
+│  │   Treasury  │  │   Staking    │  │    Marketplace      │ │
+│  │ Management  │  │   System     │  │    Economics        │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
+├─────────────────────────────────────────────────────────────┤
+│                    Economic Engine                          │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
+│  │   Token     │  │   Incentive  │  │    Simulation       │ │
+│  │   Dynamics  │  │   Optimizer  │  │    Framework        │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
+├─────────────────────────────────────────────────────────────┤
+│                    Foundation Layer                         │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
+│  │   Monetary  │  │   Game       │  │    Behavioral       │ │
+│  │   Policy    │  │   Theory     │  │    Economics        │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Dynamic Incentive Model
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Adaptive Incentives                       │
+│                                                             │
+│  Network State ──┐                                         │
+│                 ├───► Policy Engine ──┐                    │
+│  Market Data ────┘                    │                    │
+│                                      ├───► Incentive Rates │
+│  User Behavior ─────────────────────┘                    │
+│     (Participation, Quality)                              │
+│                                                             │
+│  ✓ Dynamic reward adjustment                               │
+│  ✓ Market-responsive rates                                 │
+│  ✓ Behavior-based incentives                               │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Research Methodology
+
+### Phase 1: Foundation (Months 1-2)
+
+#### 1.1 Economic Theory Analysis
+- **Tokenomics Review**: Analyze existing token models
+- **Game Theory**: Strategic interaction modeling
+- **Behavioral Economics**: User behavior patterns
+- **Macro Economics**: System-level dynamics
+
+#### 1.2 Value Flow Modeling
+- **Value Creation**: Sources of economic value
+- **Value Distribution**: Fair allocation mechanisms
+- **Value Capture**: Sustainable extraction
+- **Value Retention**: Preventing value leakage
+
+#### 1.3 Risk Analysis
+- **Market Risks**: Volatility, manipulation
+- **Systemic Risks**: Cascade failures
+- **Regulatory Risks**: Compliance requirements
+- **Adoption Risks**: Network effects
+
+### Phase 2: Model Design (Months 3-4)
+
+#### 2.1 Core Economic Engine
+```python
+class EconomicEngine:
+    def __init__(self, config: EconomicConfig):
+        self.config = config
+        self.token_dynamics = TokenDynamics(config.token)
+        self.incentive_optimizer = IncentiveOptimizer()
+        self.market_analyzer = MarketAnalyzer()
+        self.simulator = EconomicSimulator()
+    
+    async def calculate_rewards(
+        self,
+        participant: Address,
+        contribution: Contribution,
+        network_state: NetworkState
+    ) -> RewardDistribution:
+        """Calculate dynamic rewards based on contribution"""
+        
+        # Base reward calculation
+        base_reward = await self.calculate_base_reward(
+            participant, contribution
+        )
+        
+        # Adjust for network conditions
+        multiplier = await self.incentive_optimizer.get_multiplier(
+            contribution.type, network_state
+        )
+        
+        # Apply quality adjustment
+        quality_score = await self.assess_contribution_quality(
+            contribution
+        )
+        
+        # Calculate final reward
+        final_reward = RewardDistribution(
+            base=base_reward,
+            multiplier=multiplier,
+            quality_bonus=quality_score.bonus,
+            total=base_reward * multiplier * quality_score.multiplier
+        )
+        
+        return final_reward
+    
+    async def adjust_tokenomics(
+        self,
+        market_data: MarketData,
+        network_metrics: NetworkMetrics
+    ) -> TokenomicsAdjustment:
+        """Dynamically adjust tokenomic parameters"""
+        
+        # Analyze current state
+        analysis = await self.market_analyzer.analyze(
+            market_data, network_metrics
+        )
+        
+        # Identify needed adjustments
+        adjustments = await self.identify_adjustments(analysis)
+        
+        # Simulate impact
+        simulation = await self.simulator.run_simulation(
+            current_state=network_state,
+            adjustments=adjustments,
+            time_horizon=timedelta(days=30)
+        )
+        
+        # Validate adjustments
+        if await self.validate_adjustments(adjustments, simulation):
+            return adjustments
+        else:
+            return TokenomicsAdjustment()  # No changes
+    
+    async def optimize_incentives(
+        self,
+        target_metrics: TargetMetrics,
+        current_metrics: CurrentMetrics
+    ) -> IncentiveOptimization:
+        """Optimize incentive parameters to meet targets"""
+        
+        # Calculate gaps
+        gaps = self.calculate_metric_gaps(target_metrics, current_metrics)
+        
+        # Generate optimization strategies
+        strategies = await self.generate_optimization_strategies(gaps)
+        
+        # Evaluate strategies
+        evaluations = []
+        for strategy in strategies:
+            evaluation = await self.evaluate_strategy(
+                strategy, gaps, current_metrics
+            )
+            evaluations.append((strategy, evaluation))
+        
+        # Select best strategy
+        best_strategy = max(evaluations, key=lambda x: x[1].score)
+        
+        return IncentiveOptimization(
+            strategy=best_strategy[0],
+            expected_impact=best_strategy[1],
+            implementation_plan=self.create_implementation_plan(
+                best_strategy[0]
+            )
+        )
+```
+
+#### 2.2 Dynamic Tokenomics
+```python
+class DynamicTokenomics:
+    def __init__(self, initial_params: TokenomicParameters):
+        self.current_params = initial_params
+        self.adjustment_history = []
+        self.market_oracle = MarketOracle()
+        self.stability_pool = StabilityPool()
+    
+    async def adjust_inflation_rate(
+        self,
+        economic_indicators: EconomicIndicators
+    ) -> InflationAdjustment:
+        """Dynamically adjust inflation based on economic conditions"""
+        
+        # Calculate optimal inflation
+        target_inflation = await self.calculate_target_inflation(
+            economic_indicators
+        )
+        
+        # Current inflation
+        current_inflation = await self.get_current_inflation()
+        
+        # Adjustment needed
+        adjustment_rate = (target_inflation - current_inflation) / 12
+        
+        # Apply limits
+        max_adjustment = self.current_params.max_monthly_adjustment
+        adjustment_rate = max(-max_adjustment, min(max_adjustment, adjustment_rate))
+        
+        # Create adjustment
+        adjustment = InflationAdjustment(
+            new_rate=current_inflation + adjustment_rate,
+            adjustment_rate=adjustment_rate,
+            rationale=self.generate_adjustment_rationale(
+                economic_indicators, target_inflation
+            )
+        )
+        
+        return adjustment
+    
+    async def stabilize_price(
+        self,
+        price_data: PriceData,
+        target_range: PriceRange
+    ) -> StabilizationAction:
+        """Take action to stabilize token price"""
+        
+        if price_data.current_price < target_range.lower_bound:
+            # Price too low - buy back tokens
+            action = await self.create_buyback_action(price_data)
+        elif price_data.current_price > target_range.upper_bound:
+            # Price too high - increase supply
+            action = await self.create_supply_increase_action(price_data)
+        else:
+            # Price in range - no action needed
+            action = StabilizationAction(type="none")
+        
+        return action
+    
+    async def distribute_value(
+        self,
+        protocol_revenue: ProtocolRevenue,
+        distribution_params: DistributionParams
+    ) -> ValueDistribution:
+        """Distribute protocol value to stakeholders"""
+        
+        distributions = {}
+        
+        # Calculate shares
+        total_shares = sum(distribution_params.shares.values())
+        
+        for stakeholder, share_percentage in distribution_params.shares.items():
+            amount = protocol_revenue.total * (share_percentage / 100)
+            
+            if stakeholder == "stakers":
+                distributions["stakers"] = await self.distribute_to_stakers(
+                    amount, distribution_params.staker_criteria
+                )
+            elif stakeholder == "treasury":
+                distributions["treasury"] = await self.add_to_treasury(amount)
+            elif stakeholder == "developers":
+                distributions["developers"] = await self.distribute_to_developers(
+                    amount, distribution_params.dev_allocation
+                )
+            elif stakeholder == "burn":
+                distributions["burn"] = await self.burn_tokens(amount)
+        
+        return ValueDistribution(
+            total_distributed=protocol_revenue.total,
+            distributions=distributions,
+            timestamp=datetime.utcnow()
+        )
+```
+
+#### 2.3 Economic Simulation Framework
+```python
+class EconomicSimulator:
+    def __init__(self):
+        self.agent_models = AgentModelRegistry()
+        self.market_models = MarketModelRegistry()
+        self.scenario_generator = ScenarioGenerator()
+    
+    async def run_simulation(
+        self,
+        scenario: SimulationScenario,
+        time_horizon: timedelta,
+        steps: int
+    ) -> SimulationResult:
+        """Run economic simulation with given scenario"""
+        
+        # Initialize agents
+        agents = await self.initialize_agents(scenario.initial_state)
+        
+        # Initialize market
+        market = await self.initialize_market(scenario.market_params)
+        
+        # Run simulation steps
+        results = SimulationResult()
+        
+        for step in range(steps):
+            # Update agent behaviors
+            await self.update_agents(agents, market, scenario.events[step])
+            
+            # Execute market transactions
+            transactions = await self.execute_transactions(agents, market)
+            
+            # Update market state
+            await self.update_market(market, transactions)
+            
+            # Record metrics
+            metrics = await self.collect_metrics(agents, market)
+            results.add_step(step, metrics)
+        
+        # Analyze results
+        analysis = await self.analyze_results(results)
+        
+        return SimulationResult(
+            steps=results.steps,
+            metrics=results.metrics,
+            analysis=analysis
+        )
+    
+    async def stress_test(
+        self,
+        economic_model: EconomicModel,
+        stress_scenarios: List[StressScenario]
+    ) -> StressTestResults:
+        """Stress test economic model against various scenarios"""
+        
+        results = []
+        
+        for scenario in stress_scenarios:
+            # Run simulation with stress scenario
+            simulation = await self.run_simulation(
+                scenario.scenario,
+                scenario.time_horizon,
+                scenario.steps
+            )
+            
+            # Evaluate resilience
+            resilience = await self.evaluate_resilience(
+                economic_model, simulation
+            )
+            
+            results.append(StressTestResult(
+                scenario=scenario.name,
+                simulation=simulation,
+                resilience=resilience
+            ))
+        
+        return StressTestResults(results=results)
+```
+
+### Phase 3: Advanced Features (Months 5-6)
+
+#### 3.1 Cross-Chain Economics
+```python
+class CrossChainEconomics:
+    def __init__(self):
+        self.bridge_registry = BridgeRegistry()
+        self.price_oracle = CrossChainPriceOracle()
+        self.arbitrage_detector = ArbitrageDetector()
+    
+    async def calculate_cross_chain_arbitrage(
+        self,
+        token: Token,
+        chains: List[ChainId]
+    ) -> ArbitrageOpportunity:
+        """Calculate arbitrage opportunities across chains"""
+        
+        prices = {}
+        fees = {}
+        
+        # Get prices on each chain
+        for chain_id in chains:
+            price = await self.price_oracle.get_price(token, chain_id)
+            fee = await self.get_bridge_fee(chain_id)
+            prices[chain_id] = price
+            fees[chain_id] = fee
+        
+        # Find arbitrage opportunities
+        opportunities = []
+        
+        for i, buy_chain in enumerate(chains):
+            for j, sell_chain in enumerate(chains):
+                if i != j:
+                    buy_price = prices[buy_chain]
+                    sell_price = prices[sell_chain]
+                    total_fee = fees[buy_chain] + fees[sell_chain]
+                    
+                    profit = (sell_price - buy_price) - total_fee
+                    
+                    if profit > 0:
+                        opportunities.append({
+                            "buy_chain": buy_chain,
+                            "sell_chain": sell_chain,
+                            "profit": profit,
+                            "roi": profit / buy_price
+                        })
+        
+        if opportunities:
+            best = max(opportunities, key=lambda x: x["roi"])
+            return ArbitrageOpportunity(
+                token=token,
+                buy_chain=best["buy_chain"],
+                sell_chain=best["sell_chain"],
+                expected_profit=best["profit"],
+                roi=best["roi"]
+            )
+        
+        return None
+    
+    async def balance_liquidity(
+        self,
+        target_distribution: Dict[ChainId, float]
+    ) -> LiquidityRebalancing:
+        """Rebalance liquidity across chains"""
+        
+        current_distribution = await self.get_current_distribution()
+        imbalances = self.calculate_imbalances(
+            current_distribution, target_distribution
+        )
+        
+        actions = []
+        
+        for chain_id, imbalance in imbalances.items():
+            if imbalance > 0:  # Need to move liquidity out
+                action = await self.create_liquidity_transfer(
+                    from_chain=chain_id,
+                    amount=imbalance,
+                    target_chains=self.find_target_chains(
+                        imbalances, chain_id
+                    )
+                )
+                actions.append(action)
+        
+        return LiquidityRebalancing(actions=actions)
+```
+
+#### 3.2 Behavioral Economics Integration
+```python
+class BehavioralEconomics:
+    def __init__(self):
+        self.behavioral_models = BehavioralModelRegistry()
+        self.nudge_engine = NudgeEngine()
+        self.sentiment_analyzer = SentimentAnalyzer()
+    
+    async def predict_user_behavior(
+        self,
+        user: Address,
+        context: EconomicContext
+    ) -> BehaviorPrediction:
+        """Predict user economic behavior"""
+        
+        # Get user history
+        history = await self.get_user_history(user)
+        
+        # Analyze current sentiment
+        sentiment = await self.sentiment_analyzer.analyze(user, context)
+        
+        # Apply behavioral models
+        predictions = []
+        for model in self.behavioral_models.get_relevant_models(context):
+            prediction = await model.predict(history, sentiment, context)
+            predictions.append(prediction)
+        
+        # Aggregate predictions
+        aggregated = self.aggregate_predictions(predictions)
+        
+        return BehaviorPrediction(
+            user=user,
+            context=context,
+            prediction=aggregated,
+            confidence=self.calculate_confidence(predictions)
+        )
+    
+    async def design_nudges(
+        self,
+        target_behavior: str,
+        current_behavior: str
+    ) -> List[Nudge]:
+        """Design behavioral nudges to encourage target behavior"""
+        
+        nudges = []
+        
+        # Loss aversion nudge
+        if target_behavior == "stake":
+            nudges.append(Nudge(
+                type="loss_aversion",
+                message="Don't miss out on staking rewards!",
+                framing="loss"
+            ))
+        
+        # Social proof nudge
+        if target_behavior == "participate":
+            nudges.append(Nudge(
+                type="social_proof",
+                message="Join 10,000 others earning rewards!",
+                framing="social"
+            ))
+        
+        # Default option nudge
+        if target_behavior == "auto_compound":
+            nudges.append(Nudge(
+                type="default_option",
+                message="Auto-compounding is enabled by default",
+                framing="default"
+            ))
+        
+        return nudges
+```
+
+### Phase 4: Implementation & Testing (Months 7-8)
+
+#### 4.1 Smart Contract Implementation
+- **Treasury Management**: Automated fund management
+- **Reward Distribution**: Dynamic reward calculation
+- **Stability Pool**: Price stabilization mechanism
+- **Governance Integration**: Economic parameter voting
+
+#### 4.2 Off-Chain Infrastructure
+- **Oracle Network**: Price and economic data
+- **Simulation Platform**: Policy testing environment
+- **Analytics Dashboard**: Economic metrics visualization
+- **Alert System**: Anomaly detection
+
+#### 4.3 Testing & Validation
+- **Model Validation**: Backtesting against historical data
+- **Stress Testing**: Extreme scenario testing
+- **Agent-Based Testing**: Behavioral validation
+- **Integration Testing**: End-to-end workflows
+
+## Technical Specifications
+
+### Economic Parameters
+
+| Parameter | Initial Range | Adjustment Mechanism |
+|-----------|---------------|---------------------|
+| Inflation Rate | 2-8% | Monthly adjustment |
+| Staking Reward | 5-15% APY | Dynamic based on participation |
+| Stability Fee | 0.1-1% | Market-based |
+| Treasury Tax | 0.5-5% | Governance vote |
+| Burn Rate | 0-50% | Protocol decision |
+
+### Incentive Models
+
+| Model | Use Case | Adjustment Frequency |
+|-------|----------|---------------------|
+| Linear Reward | Basic participation | Daily |
+| Quadratic Reward | Quality contribution | Weekly |
+| Exponential Decay | Early adoption | Fixed |
+| Dynamic Multiplier | Network conditions | Real-time |
+
+### Simulation Scenarios
+
+| Scenario | Description | Key Metrics |
+|----------|-------------|-------------|
+| Bull Market | Rapid price increase | Inflation, distribution |
+| Bear Market | Price decline | Stability, retention |
+| Network Growth | User adoption | Scalability, rewards |
+| Regulatory Shock | Compliance requirements | Adaptation, resilience |
+
+## Economic Analysis
+
+### Value Creation Sources
+
+1. **Network Utility**: Transaction fees, service charges
+2. **Data Value**: AI model marketplace
+3. **Staking Security**: Network security contribution
+4. **Development Value**: Protocol improvements
+5. **Ecosystem Growth**: New applications
+
+### Value Distribution
+
+1. **Stakers (40%)**: Network security rewards
+2. **Treasury (30%)**: Development and ecosystem
+3. **Developers (20%)**: Application builders
+4. **Burn (10%)**: Deflationary pressure
+
+### Stability Mechanisms
+
+1. **Algorithmic Stabilization**: Supply/demand balancing
+2. **Reserve Pool**: Emergency stabilization
+3. **Market Operations**: Open market operations
+4. **Governance Intervention**: Community decisions
+
+## Implementation Plan
+
+### Phase 1: Foundation (Months 1-2)
+- [ ] Complete economic theory review
+- [ ] Design value flow models
+- [ ] Create risk analysis framework
+- [ ] Set up simulation infrastructure
+
+### Phase 2: Core Models (Months 3-4)
+- [ ] Implement economic engine
+- [ ] Build dynamic tokenomics
+- [ ] Create simulation framework
+- [ ] Develop smart contracts
+
+### Phase 3: Advanced Features (Months 5-6)
+- [ ] Add cross-chain economics
+- [ ] Implement behavioral models
+- [ ] Create analytics platform
+- [ ] Build alert system
+
+### Phase 4: Testing (Months 7-8)
+- [ ] Model validation
+- [ ] Stress testing
+- [ ] Security audits
+- [ ] Community feedback
+
+### Phase 5: Deployment (Months 9-12)
+- [ ] Testnet deployment
+- [ ] Mainnet launch
+- [ ] Monitoring setup
+- [ ] Optimization
+
+## Deliverables
+
+### Technical Deliverables
+1. **Economic Engine** (Month 4)
+2. **Simulation Platform** (Month 6)
+3. **Analytics Dashboard** (Month 8)
+4. **Stability Mechanism** (Month 10)
+5. **Mainnet Deployment** (Month 12)
+
+### Research Deliverables
+1. **Economic Whitepaper** (Month 2)
+2. **Technical Papers**: 3 papers
+3. **Model Documentation**: Complete specifications
+4. **Simulation Results**: Performance analysis
+
+### Community Deliverables
+1. **Economic Education**: Understanding tokenomics
+2. **Tools**: Economic calculators, simulators
+3. **Reports**: Regular economic updates
+4. **Governance**: Economic parameter voting
+
+## Resource Requirements
+
+### Team
+- **Principal Economist** (1): Economic theory lead
+- **Quantitative Analysts** (3): Model development
+- **Behavioral Economists** (2): User behavior
+- **Blockchain Engineers** (3): Implementation
+- **Data Scientists** (2): Analytics, ML
+- **Policy Experts** (1): Regulatory compliance
+
+### Infrastructure
+- **Computing Cluster**: For simulation and modeling
+- **Data Infrastructure**: Economic data storage
+- **Oracle Network**: Price and market data
+- **Analytics Platform**: Real-time monitoring
+
+### Budget
+- **Personnel**: $7M
+- **Infrastructure**: $1.5M
+- **Research**: $1M
+- **Community**: $500K
+
+## Success Metrics
+
+### Economic Metrics
+- [ ] Stable token price (±10% volatility)
+- [ ] Sustainable inflation (2-5%)
+- [ ] High staking participation (>60%)
+- [ ] Positive value capture (>20% of fees)
+- [ ] Economic resilience (passes stress tests)
+
+### Adoption Metrics
+- [ ] 100,000+ token holders
+- [ ] 10,000+ active stakers
+- [ ] 50+ ecosystem applications
+- [ ] $1B+ TVL (Total Value Locked)
+- [ ] 90%+ governance participation
+
+### Research Metrics
+- [ ] 3+ papers published
+- [ ] 2+ economic models adopted
+- [ ] 10+ academic collaborations
+- [ ] Industry recognition
+- [ ] Open source adoption
+
+## Risk Mitigation
+
+### Economic Risks
+1. **Volatility**: Price instability
+   - Mitigation: Stabilization mechanisms, reserves
+2. **Inflation**: Value dilution
+   - Mitigation: Dynamic adjustment, burning
+3. **Centralization**: Wealth concentration
+   - Mitigation: Distribution mechanisms, limits
+
+### Implementation Risks
+1. **Model Errors**: Incorrect economic models
+   - Mitigation: Simulation, testing, iteration
+2. **Oracle Failures**: Bad price data
+   - Mitigation: Multiple oracles, validation
+3. **Smart Contract Bugs**: Security issues
+   - Mitigation: Audits, formal verification
+
+### External Risks
+1. **Market Conditions**: Unfavorable markets
+   - Mitigation: Adaptive mechanisms, reserves
+2. **Regulatory**: Legal restrictions
+   - Mitigation: Compliance, legal review
+3. **Competition**: Better alternatives
+   - Mitigation: Innovation, differentiation
+
+## Conclusion
+
+This research plan establishes a comprehensive approach to blockchain economics that is dynamic, adaptive, and sustainable. The combination of traditional economic principles with modern blockchain technology creates an economic system that can evolve with market conditions while maintaining stability and fairness.
+
+The 12-month timeline with clear deliverables ensures steady progress toward a production-ready economic system. The research outcomes will benefit not only AITBC but the entire blockchain ecosystem by advancing the state of economic design for decentralized networks.
+
+By focusing on practical implementation and real-world testing, we ensure that the economic models translate into sustainable value creation for all ecosystem participants.
+
+---
+
+*This research plan will evolve based on market conditions and community feedback. Regular reviews ensure alignment with ecosystem needs.*