oib/aitbc
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

docs: add code quality and type checking workflows to master index
Some checks failed
Documentation Validation / validate-docs (push) Has been cancelled
Details
Python Tests / test-python (push) Has been cancelled
Details
API Endpoint Tests / test-api-endpoints (push) Has been cancelled
Details
CLI Tests / test-cli (push) Has been cancelled
Details
Integration Tests / test-service-integration (push) Has been cancelled
Details
Package Tests / test-python-packages (map[name:aitbc-agent-sdk path:packages/py/aitbc-agent-sdk]) (push) Has been cancelled
Details
Package Tests / test-python-packages (map[name:aitbc-core path:packages/py/aitbc-core]) (push) Has been cancelled
Details
Package Tests / test-python-packages (map[name:aitbc-crypto path:packages/py/aitbc-crypto]) (push) Has been cancelled
Details
Package Tests / test-python-packages (map[name:aitbc-sdk path:packages/py/aitbc-sdk]) (push) Has been cancelled
Details
Package Tests / test-javascript-packages (map[name:aitbc-sdk-js path:packages/js/aitbc-sdk]) (push) Has been cancelled
Details
Package Tests / test-javascript-packages (map[name:aitbc-token path:packages/solidity/aitbc-token]) (push) Has been cancelled
Details
Security Scanning / security-scan (push) Has been cancelled
Details
Systemd Sync / sync-systemd (push) Has been cancelled
Details

Browse Source 
- Add Code Quality Module section with pre-commit hooks and quality checks
- Add Type Checking CI/CD Module section with MyPy workflow and coverage
- Update README with code quality achievements and project structure
- Migrate FastAPI apps from deprecated on_event to lifespan context manager
- Update pyproject.toml files to reference consolidated dependencies
- Remove unused app.py import in coordinator-api
- Add type hints to agent
This commit is contained in:
aitbc
2026-03-31 21:45:43 +02:00
parent 26592ddf55
commit 9db720add8
308 changed files with 34194 additions and 34575 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
apps/coordinator-api/src/app/domain/__init__.py
View File

@@ -1,13 +1,21 @@
"""Domain models for the coordinator API."""
from .agent import (
AgentExecution,
AgentMarketplace,
AgentStatus,
AgentStep,
AgentStepExecution,
AIAgentWorkflow,
VerificationLevel,
)
from .gpu_marketplace import ConsumerGPUProfile, EdgeGPUMetrics, GPUBooking, GPURegistry, GPUReview
from .job import Job
from .miner import Miner
from .job_receipt import JobReceipt
from .marketplace import MarketplaceOffer, MarketplaceBid
from .user import User, Wallet, Transaction, UserSession
from .marketplace import MarketplaceBid, MarketplaceOffer
from .miner import Miner
from .payment import JobPayment, PaymentEscrow
from .gpu_marketplace import GPURegistry, ConsumerGPUProfile, EdgeGPUMetrics, GPUBooking, GPUReview
from .agent import AIAgentWorkflow, AgentStep, AgentExecution, AgentStepExecution, AgentMarketplace, AgentStatus
from .user import Transaction, User, UserSession, Wallet
__all__ = [
"Job",
@@ -32,4 +40,5 @@ __all__ = [
"AgentStepExecution",
"AgentMarketplace",
"AgentStatus",
"VerificationLevel",
]

207
apps/coordinator-api/src/app/domain/agent.py
View File

@@ -4,16 +4,16 @@ Implements SQLModel definitions for agent workflows, steps, and execution tracki
"""
from datetime import datetime
from typing import Optional, Dict, List, Any
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime
from sqlmodel import JSON, Column, Field, SQLModel
class AgentStatus(str, Enum):
class AgentStatus(StrEnum):
"""Agent execution status enumeration"""
PENDING = "pending"
RUNNING = "running"
COMPLETED = "completed"
@@ -21,15 +21,17 @@ class AgentStatus(str, Enum):
CANCELLED = "cancelled"
class VerificationLevel(str, Enum):
class VerificationLevel(StrEnum):
"""Verification level for agent execution"""
BASIC = "basic"
FULL = "full"
ZERO_KNOWLEDGE = "zero-knowledge"
class StepType(str, Enum):
class StepType(StrEnum):
"""Agent step type enumeration"""
INFERENCE = "inference"
TRAINING = "training"
DATA_PROCESSING = "data_processing"
@@ -39,32 +41,32 @@ class StepType(str, Enum):
class AIAgentWorkflow(SQLModel, table=True):
"""Definition of an AI agent workflow"""
__tablename__ = "ai_agent_workflows"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"agent_{uuid4().hex[:8]}", primary_key=True)
owner_id: str = Field(index=True)
name: str = Field(max_length=100)
description: str = Field(default="")
# Workflow specification
steps: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
dependencies: Dict[str, List[str]] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
steps: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
dependencies: dict[str, list[str]] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
# Execution constraints
max_execution_time: int = Field(default=3600) # seconds
max_cost_budget: float = Field(default=0.0)
# Verification requirements
requires_verification: bool = Field(default=True)
verification_level: VerificationLevel = Field(default=VerificationLevel.BASIC)
# Metadata
tags: str = Field(default="") # JSON string of tags
version: str = Field(default="1.0.0")
is_public: bool = Field(default=False)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -72,33 +74,33 @@ class AIAgentWorkflow(SQLModel, table=True):
class AgentStep(SQLModel, table=True):
"""Individual step in an AI agent workflow"""
__tablename__ = "agent_steps"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"step_{uuid4().hex[:8]}", primary_key=True)
workflow_id: str = Field(index=True)
step_order: int = Field(default=0)
# Step specification
name: str = Field(max_length=100)
step_type: StepType = Field(default=StepType.INFERENCE)
model_requirements: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
input_mappings: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
output_mappings: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
model_requirements: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
input_mappings: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
output_mappings: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Execution parameters
timeout_seconds: int = Field(default=300)
retry_policy: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
retry_policy: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
max_retries: int = Field(default=3)
# Verification
requires_proof: bool = Field(default=False)
verification_level: VerificationLevel = Field(default=VerificationLevel.BASIC)
# Dependencies
depends_on: str = Field(default="") # JSON string of step IDs
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -106,38 +108,38 @@ class AgentStep(SQLModel, table=True):
class AgentExecution(SQLModel, table=True):
"""Tracks execution state of AI agent workflows"""
__tablename__ = "agent_executions"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"exec_{uuid4().hex[:10]}", primary_key=True)
workflow_id: str = Field(index=True)
client_id: str = Field(index=True)
# Execution state
status: AgentStatus = Field(default=AgentStatus.PENDING)
current_step: int = Field(default=0)
step_states: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
step_states: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
# Results and verification
final_result: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
execution_receipt: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
verification_proof: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
final_result: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
execution_receipt: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
verification_proof: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
# Error handling
error_message: Optional[str] = Field(default=None)
failed_step: Optional[str] = Field(default=None)
error_message: str | None = Field(default=None)
failed_step: str | None = Field(default=None)
# Timing and cost
started_at: Optional[datetime] = Field(default=None)
completed_at: Optional[datetime] = Field(default=None)
total_execution_time: Optional[float] = Field(default=None) # seconds
started_at: datetime | None = Field(default=None)
completed_at: datetime | None = Field(default=None)
total_execution_time: float | None = Field(default=None) # seconds
total_cost: float = Field(default=0.0)
# Progress tracking
total_steps: int = Field(default=0)
completed_steps: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -145,38 +147,38 @@ class AgentExecution(SQLModel, table=True):
class AgentStepExecution(SQLModel, table=True):
"""Tracks execution of individual steps within an agent workflow"""
__tablename__ = "agent_step_executions"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"step_exec_{uuid4().hex[:10]}", primary_key=True)
execution_id: str = Field(index=True)
step_id: str = Field(index=True)
# Execution state
status: AgentStatus = Field(default=AgentStatus.PENDING)
# Step-specific data
input_data: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
output_data: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
input_data: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
output_data: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
# Performance metrics
execution_time: Optional[float] = Field(default=None) # seconds
execution_time: float | None = Field(default=None) # seconds
gpu_accelerated: bool = Field(default=False)
memory_usage: Optional[float] = Field(default=None) # MB
memory_usage: float | None = Field(default=None) # MB
# Verification
step_proof: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
verification_status: Optional[str] = Field(default=None)
step_proof: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
verification_status: str | None = Field(default=None)
# Error handling
error_message: Optional[str] = Field(default=None)
error_message: str | None = Field(default=None)
retry_count: int = Field(default=0)
# Timing
started_at: Optional[datetime] = Field(default=None)
completed_at: Optional[datetime] = Field(default=None)
started_at: datetime | None = Field(default=None)
completed_at: datetime | None = Field(default=None)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -184,38 +186,38 @@ class AgentStepExecution(SQLModel, table=True):
class AgentMarketplace(SQLModel, table=True):
"""Marketplace for AI agent workflows"""
__tablename__ = "agent_marketplace"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"amkt_{uuid4().hex[:8]}", primary_key=True)
workflow_id: str = Field(index=True)
# Marketplace metadata
title: str = Field(max_length=200)
description: str = Field(default="")
tags: str = Field(default="") # JSON string of tags
category: str = Field(default="general")
# Pricing
execution_price: float = Field(default=0.0)
subscription_price: float = Field(default=0.0)
pricing_model: str = Field(default="pay-per-use") # pay-per-use, subscription, freemium
# Reputation and usage
rating: float = Field(default=0.0)
total_executions: int = Field(default=0)
successful_executions: int = Field(default=0)
average_execution_time: Optional[float] = Field(default=None)
average_execution_time: float | None = Field(default=None)
# Access control
is_public: bool = Field(default=True)
authorized_users: str = Field(default="") # JSON string of authorized users
# Performance metrics
last_execution_status: Optional[AgentStatus] = Field(default=None)
last_execution_at: Optional[datetime] = Field(default=None)
last_execution_status: AgentStatus | None = Field(default=None)
last_execution_at: datetime | None = Field(default=None)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -224,66 +226,71 @@ class AgentMarketplace(SQLModel, table=True):
# Request/Response Models for API
class AgentWorkflowCreate(SQLModel):
"""Request model for creating agent workflows"""
name: str = Field(max_length=100)
description: str = Field(default="")
steps: Dict[str, Any]
dependencies: Dict[str, List[str]] = Field(default_factory=dict)
steps: dict[str, Any]
dependencies: dict[str, list[str]] = Field(default_factory=dict)
max_execution_time: int = Field(default=3600)
max_cost_budget: float = Field(default=0.0)
requires_verification: bool = Field(default=True)
verification_level: VerificationLevel = Field(default=VerificationLevel.BASIC)
tags: List[str] = Field(default_factory=list)
tags: list[str] = Field(default_factory=list)
is_public: bool = Field(default=False)
class AgentWorkflowUpdate(SQLModel):
"""Request model for updating agent workflows"""
name: Optional[str] = Field(default=None, max_length=100)
description: Optional[str] = Field(default=None)
steps: Optional[Dict[str, Any]] = Field(default=None)
dependencies: Optional[Dict[str, List[str]]] = Field(default=None)
max_execution_time: Optional[int] = Field(default=None)
max_cost_budget: Optional[float] = Field(default=None)
requires_verification: Optional[bool] = Field(default=None)
verification_level: Optional[VerificationLevel] = Field(default=None)
tags: Optional[List[str]] = Field(default=None)
is_public: Optional[bool] = Field(default=None)
name: str | None = Field(default=None, max_length=100)
description: str | None = Field(default=None)
steps: dict[str, Any] | None = Field(default=None)
dependencies: dict[str, list[str]] | None = Field(default=None)
max_execution_time: int | None = Field(default=None)
max_cost_budget: float | None = Field(default=None)
requires_verification: bool | None = Field(default=None)
verification_level: VerificationLevel | None = Field(default=None)
tags: list[str] | None = Field(default=None)
is_public: bool | None = Field(default=None)
class AgentExecutionRequest(SQLModel):
"""Request model for executing agent workflows"""
workflow_id: str
inputs: Dict[str, Any]
verification_level: Optional[VerificationLevel] = Field(default=VerificationLevel.BASIC)
max_execution_time: Optional[int] = Field(default=None)
max_cost_budget: Optional[float] = Field(default=None)
inputs: dict[str, Any]
verification_level: VerificationLevel | None = Field(default=VerificationLevel.BASIC)
max_execution_time: int | None = Field(default=None)
max_cost_budget: float | None = Field(default=None)
class AgentExecutionResponse(SQLModel):
"""Response model for agent execution"""
execution_id: str
workflow_id: str
status: AgentStatus
current_step: int
total_steps: int
started_at: Optional[datetime]
estimated_completion: Optional[datetime]
started_at: datetime | None
estimated_completion: datetime | None
current_cost: float
estimated_total_cost: Optional[float]
estimated_total_cost: float | None
class AgentExecutionStatus(SQLModel):
"""Response model for execution status"""
execution_id: str
workflow_id: str
status: AgentStatus
current_step: int
total_steps: int
step_states: Dict[str, Any]
final_result: Optional[Dict[str, Any]]
error_message: Optional[str]
started_at: Optional[datetime]
completed_at: Optional[datetime]
total_execution_time: Optional[float]
step_states: dict[str, Any]
final_result: dict[str, Any] | None
error_message: str | None
started_at: datetime | None
completed_at: datetime | None
total_execution_time: float | None
total_cost: float
verification_proof: Optional[Dict[str, Any]]
verification_proof: dict[str, Any] | None

257
apps/coordinator-api/src/app/domain/agent_identity.py
View File

@@ -4,32 +4,35 @@ Implements SQLModel definitions for unified agent identity across multiple block
"""
from datetime import datetime
from typing import Optional, Dict, List, Any
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Index
from sqlalchemy import Index
from sqlmodel import JSON, Column, Field, SQLModel
class IdentityStatus(str, Enum):
class IdentityStatus(StrEnum):
"""Agent identity status enumeration"""
ACTIVE = "active"
INACTIVE = "inactive"
SUSPENDED = "suspended"
REVOKED = "revoked"
class VerificationType(str, Enum):
class VerificationType(StrEnum):
"""Identity verification type enumeration"""
BASIC = "basic"
ADVANCED = "advanced"
ZERO_KNOWLEDGE = "zero-knowledge"
MULTI_SIGNATURE = "multi-signature"
class ChainType(str, Enum):
class ChainType(StrEnum):
"""Blockchain chain type enumeration"""
ETHEREUM = "ethereum"
POLYGON = "polygon"
BSC = "bsc"
@@ -42,268 +45,276 @@ class ChainType(str, Enum):
class AgentIdentity(SQLModel, table=True):
"""Unified agent identity across blockchains"""
__tablename__ = "agent_identities"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"identity_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, unique=True) # Links to AIAgentWorkflow.id
owner_address: str = Field(index=True)
# Identity metadata
display_name: str = Field(max_length=100, default="")
description: str = Field(default="")
avatar_url: str = Field(default="")
# Status and verification
status: IdentityStatus = Field(default=IdentityStatus.ACTIVE)
verification_level: VerificationType = Field(default=VerificationType.BASIC)
is_verified: bool = Field(default=False)
verified_at: Optional[datetime] = Field(default=None)
verified_at: datetime | None = Field(default=None)
# Cross-chain capabilities
supported_chains: List[str] = Field(default_factory=list, sa_column=Column(JSON))
supported_chains: list[str] = Field(default_factory=list, sa_column=Column(JSON))
primary_chain: int = Field(default=1) # Default to Ethereum mainnet
# Reputation and trust
reputation_score: float = Field(default=0.0)
total_transactions: int = Field(default=0)
successful_transactions: int = Field(default=0)
last_activity: Optional[datetime] = Field(default=None)
last_activity: datetime | None = Field(default=None)
# Metadata and settings
identity_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
settings_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
tags: List[str] = Field(default_factory=list, sa_column=Column(JSON))
identity_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
settings_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
tags: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Indexes for performance
__table_args__ = (
Index('idx_agent_identity_owner', 'owner_address'),
Index('idx_agent_identity_status', 'status'),
Index('idx_agent_identity_verified', 'is_verified'),
Index('idx_agent_identity_reputation', 'reputation_score'),
Index("idx_agent_identity_owner", "owner_address"),
Index("idx_agent_identity_status", "status"),
Index("idx_agent_identity_verified", "is_verified"),
Index("idx_agent_identity_reputation", "reputation_score"),
)
class CrossChainMapping(SQLModel, table=True):
"""Mapping of agent identity across different blockchains"""
__tablename__ = "cross_chain_mappings"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"mapping_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True)
chain_id: int = Field(index=True)
chain_type: ChainType = Field(default=ChainType.ETHEREUM)
chain_address: str = Field(index=True)
# Verification and status
is_verified: bool = Field(default=False)
verified_at: Optional[datetime] = Field(default=None)
verification_proof: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
verified_at: datetime | None = Field(default=None)
verification_proof: dict[str, Any] | None = Field(default=None, sa_column=Column(JSON))
# Wallet information
wallet_address: Optional[str] = Field(default=None)
wallet_address: str | None = Field(default=None)
wallet_type: str = Field(default="agent-wallet") # agent-wallet, external-wallet, etc.
# Chain-specific metadata
chain_meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
nonce: Optional[int] = Field(default=None)
chain_meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
nonce: int | None = Field(default=None)
# Activity tracking
last_transaction: Optional[datetime] = Field(default=None)
last_transaction: datetime | None = Field(default=None)
transaction_count: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Unique constraint
__table_args__ = (
Index('idx_cross_chain_agent_chain', 'agent_id', 'chain_id'),
Index('idx_cross_chain_address', 'chain_address'),
Index('idx_cross_chain_verified', 'is_verified'),
Index("idx_cross_chain_agent_chain", "agent_id", "chain_id"),
Index("idx_cross_chain_address", "chain_address"),
Index("idx_cross_chain_verified", "is_verified"),
)
class IdentityVerification(SQLModel, table=True):
"""Verification records for cross-chain identities"""
__tablename__ = "identity_verifications"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"verify_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True)
chain_id: int = Field(index=True)
# Verification details
verification_type: VerificationType
verifier_address: str = Field(index=True) # Who performed the verification
proof_hash: str = Field(index=True)
proof_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
proof_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Status and results
is_valid: bool = Field(default=True)
verification_result: str = Field(default="pending") # pending, approved, rejected
rejection_reason: Optional[str] = Field(default=None)
rejection_reason: str | None = Field(default=None)
# Expiration and renewal
expires_at: Optional[datetime] = Field(default=None)
renewed_at: Optional[datetime] = Field(default=None)
expires_at: datetime | None = Field(default=None)
renewed_at: datetime | None = Field(default=None)
# Metadata
verification_meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
verification_meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Indexes
__table_args__ = (
Index('idx_identity_verify_agent_chain', 'agent_id', 'chain_id'),
Index('idx_identity_verify_verifier', 'verifier_address'),
Index('idx_identity_verify_hash', 'proof_hash'),
Index('idx_identity_verify_result', 'verification_result'),
Index("idx_identity_verify_agent_chain", "agent_id", "chain_id"),
Index("idx_identity_verify_verifier", "verifier_address"),
Index("idx_identity_verify_hash", "proof_hash"),
Index("idx_identity_verify_result", "verification_result"),
)
class AgentWallet(SQLModel, table=True):
"""Agent wallet information for cross-chain operations"""
__tablename__ = "agent_wallets"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"wallet_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True)
chain_id: int = Field(index=True)
chain_address: str = Field(index=True)
# Wallet details
wallet_type: str = Field(default="agent-wallet")
contract_address: Optional[str] = Field(default=None)
contract_address: str | None = Field(default=None)
# Financial information
balance: float = Field(default=0.0)
spending_limit: float = Field(default=0.0)
total_spent: float = Field(default=0.0)
# Status and permissions
is_active: bool = Field(default=True)
permissions: List[str] = Field(default_factory=list, sa_column=Column(JSON))
permissions: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Security
requires_multisig: bool = Field(default=False)
multisig_threshold: int = Field(default=1)
multisig_signers: List[str] = Field(default_factory=list, sa_column=Column(JSON))
multisig_signers: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Activity tracking
last_transaction: Optional[datetime] = Field(default=None)
last_transaction: datetime | None = Field(default=None)
transaction_count: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Indexes
__table_args__ = (
Index('idx_agent_wallet_agent_chain', 'agent_id', 'chain_id'),
Index('idx_agent_wallet_address', 'chain_address'),
Index('idx_agent_wallet_active', 'is_active'),
Index("idx_agent_wallet_agent_chain", "agent_id", "chain_id"),
Index("idx_agent_wallet_address", "chain_address"),
Index("idx_agent_wallet_active", "is_active"),
)
# Request/Response Models for API
class AgentIdentityCreate(SQLModel):
"""Request model for creating agent identities"""
agent_id: str
owner_address: str
display_name: str = Field(max_length=100, default="")
description: str = Field(default="")
avatar_url: str = Field(default="")
supported_chains: List[int] = Field(default_factory=list)
supported_chains: list[int] = Field(default_factory=list)
primary_chain: int = Field(default=1)
meta_data: Dict[str, Any] = Field(default_factory=dict)
tags: List[str] = Field(default_factory=list)
meta_data: dict[str, Any] = Field(default_factory=dict)
tags: list[str] = Field(default_factory=list)
class AgentIdentityUpdate(SQLModel):
"""Request model for updating agent identities"""
display_name: Optional[str] = Field(default=None, max_length=100)
description: Optional[str] = Field(default=None)
avatar_url: Optional[str] = Field(default=None)
status: Optional[IdentityStatus] = Field(default=None)
verification_level: Optional[VerificationType] = Field(default=None)
supported_chains: Optional[List[int]] = Field(default=None)
primary_chain: Optional[int] = Field(default=None)
meta_data: Optional[Dict[str, Any]] = Field(default=None)
settings: Optional[Dict[str, Any]] = Field(default=None)
tags: Optional[List[str]] = Field(default=None)
display_name: str | None = Field(default=None, max_length=100)
description: str | None = Field(default=None)
avatar_url: str | None = Field(default=None)
status: IdentityStatus | None = Field(default=None)
verification_level: VerificationType | None = Field(default=None)
supported_chains: list[int] | None = Field(default=None)
primary_chain: int | None = Field(default=None)
meta_data: dict[str, Any] | None = Field(default=None)
settings: dict[str, Any] | None = Field(default=None)
tags: list[str] | None = Field(default=None)
class CrossChainMappingCreate(SQLModel):
"""Request model for creating cross-chain mappings"""
agent_id: str
chain_id: int
chain_type: ChainType = Field(default=ChainType.ETHEREUM)
chain_address: str
wallet_address: Optional[str] = Field(default=None)
wallet_address: str | None = Field(default=None)
wallet_type: str = Field(default="agent-wallet")
chain_meta_data: Dict[str, Any] = Field(default_factory=dict)
chain_meta_data: dict[str, Any] = Field(default_factory=dict)
class CrossChainMappingUpdate(SQLModel):
"""Request model for updating cross-chain mappings"""
chain_address: Optional[str] = Field(default=None)
wallet_address: Optional[str] = Field(default=None)
wallet_type: Optional[str] = Field(default=None)
chain_meta_data: Optional[Dict[str, Any]] = Field(default=None)
is_verified: Optional[bool] = Field(default=None)
chain_address: str | None = Field(default=None)
wallet_address: str | None = Field(default=None)
wallet_type: str | None = Field(default=None)
chain_meta_data: dict[str, Any] | None = Field(default=None)
is_verified: bool | None = Field(default=None)
class IdentityVerificationCreate(SQLModel):
"""Request model for creating identity verifications"""
agent_id: str
chain_id: int
verification_type: VerificationType
verifier_address: str
proof_hash: str
proof_data: Dict[str, Any] = Field(default_factory=dict)
expires_at: Optional[datetime] = Field(default=None)
verification_meta_data: Dict[str, Any] = Field(default_factory=dict)
proof_data: dict[str, Any] = Field(default_factory=dict)
expires_at: datetime | None = Field(default=None)
verification_meta_data: dict[str, Any] = Field(default_factory=dict)
class AgentWalletCreate(SQLModel):
"""Request model for creating agent wallets"""
agent_id: str
chain_id: int
chain_address: str
wallet_type: str = Field(default="agent-wallet")
contract_address: Optional[str] = Field(default=None)
contract_address: str | None = Field(default=None)
spending_limit: float = Field(default=0.0)
permissions: List[str] = Field(default_factory=list)
permissions: list[str] = Field(default_factory=list)
requires_multisig: bool = Field(default=False)
multisig_threshold: int = Field(default=1)
multisig_signers: List[str] = Field(default_factory=list)
multisig_signers: list[str] = Field(default_factory=list)
class AgentWalletUpdate(SQLModel):
"""Request model for updating agent wallets"""
contract_address: Optional[str] = Field(default=None)
spending_limit: Optional[float] = Field(default=None)
permissions: Optional[List[str]] = Field(default=None)
is_active: Optional[bool] = Field(default=None)
requires_multisig: Optional[bool] = Field(default=None)
multisig_threshold: Optional[int] = Field(default=None)
multisig_signers: Optional[List[str]] = Field(default=None)
contract_address: str | None = Field(default=None)
spending_limit: float | None = Field(default=None)
permissions: list[str] | None = Field(default=None)
is_active: bool | None = Field(default=None)
requires_multisig: bool | None = Field(default=None)
multisig_threshold: int | None = Field(default=None)
multisig_signers: list[str] | None = Field(default=None)
# Response Models
class AgentIdentityResponse(SQLModel):
"""Response model for agent identity"""
id: str
agent_id: str
owner_address: str
@@ -313,32 +324,33 @@ class AgentIdentityResponse(SQLModel):
status: IdentityStatus
verification_level: VerificationType
is_verified: bool
verified_at: Optional[datetime]
supported_chains: List[str]
verified_at: datetime | None
supported_chains: list[str]
primary_chain: int
reputation_score: float
total_transactions: int
successful_transactions: int
last_activity: Optional[datetime]
meta_data: Dict[str, Any]
tags: List[str]
last_activity: datetime | None
meta_data: dict[str, Any]
tags: list[str]
created_at: datetime
updated_at: datetime
class CrossChainMappingResponse(SQLModel):
"""Response model for cross-chain mapping"""
id: str
agent_id: str
chain_id: int
chain_type: ChainType
chain_address: str
is_verified: bool
verified_at: Optional[datetime]
wallet_address: Optional[str]
verified_at: datetime | None
wallet_address: str | None
wallet_type: str
chain_meta_data: Dict[str, Any]
last_transaction: Optional[datetime]
chain_meta_data: dict[str, Any]
last_transaction: datetime | None
transaction_count: int
created_at: datetime
updated_at: datetime
@@ -346,21 +358,22 @@ class CrossChainMappingResponse(SQLModel):
class AgentWalletResponse(SQLModel):
"""Response model for agent wallet"""
id: str
agent_id: str
chain_id: int
chain_address: str
wallet_type: str
contract_address: Optional[str]
contract_address: str | None
balance: float
spending_limit: float
total_spent: float
is_active: bool
permissions: List[str]
permissions: list[str]
requires_multisig: bool
multisig_threshold: int
multisig_signers: List[str]
last_transaction: Optional[datetime]
multisig_signers: list[str]
last_transaction: datetime | None
transaction_count: int
created_at: datetime
updated_at: datetime

365
apps/coordinator-api/src/app/domain/agent_performance.py
View File

@@ -3,17 +3,17 @@ Advanced Agent Performance Domain Models
Implements SQLModel definitions for meta-learning, resource management, and performance optimization
"""
from datetime import datetime, timedelta
from typing import Optional, Dict, List, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Float, Integer, Text
from sqlmodel import JSON, Column, Field, SQLModel
class LearningStrategy(str, Enum):
class LearningStrategy(StrEnum):
"""Learning strategy enumeration"""
META_LEARNING = "meta_learning"
TRANSFER_LEARNING = "transfer_learning"
REINFORCEMENT_LEARNING = "reinforcement_learning"
@@ -22,8 +22,9 @@ class LearningStrategy(str, Enum):
FEDERATED_LEARNING = "federated_learning"
class PerformanceMetric(str, Enum):
class PerformanceMetric(StrEnum):
"""Performance metric enumeration"""
ACCURACY = "accuracy"
PRECISION = "precision"
RECALL = "recall"
@@ -36,8 +37,9 @@ class PerformanceMetric(str, Enum):
GENERALIZATION = "generalization"
class ResourceType(str, Enum):
class ResourceType(StrEnum):
"""Resource type enumeration"""
CPU = "cpu"
GPU = "gpu"
MEMORY = "memory"
@@ -46,8 +48,9 @@ class ResourceType(str, Enum):
CACHE = "cache"
class OptimizationTarget(str, Enum):
class OptimizationTarget(StrEnum):
"""Optimization target enumeration"""
SPEED = "speed"
ACCURACY = "accuracy"
EFFICIENCY = "efficiency"
@@ -58,121 +61,121 @@ class OptimizationTarget(str, Enum):
class AgentPerformanceProfile(SQLModel, table=True):
"""Agent performance profiles and metrics"""
__tablename__ = "agent_performance_profiles"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"perf_{uuid4().hex[:8]}", primary_key=True)
profile_id: str = Field(unique=True, index=True)
# Agent identification
agent_id: str = Field(index=True)
agent_type: str = Field(default="openclaw")
agent_version: str = Field(default="1.0.0")
# Performance metrics
overall_score: float = Field(default=0.0, ge=0, le=100)
performance_metrics: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
performance_metrics: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Learning capabilities
learning_strategies: List[str] = Field(default=[], sa_column=Column(JSON))
learning_strategies: list[str] = Field(default=[], sa_column=Column(JSON))
adaptation_rate: float = Field(default=0.0, ge=0, le=1.0)
generalization_score: float = Field(default=0.0, ge=0, le=1.0)
# Resource utilization
resource_efficiency: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
resource_efficiency: dict[str, float] = Field(default={}, sa_column=Column(JSON))
cost_per_task: float = Field(default=0.0)
throughput: float = Field(default=0.0)
average_latency: float = Field(default=0.0)
# Specialization areas
specialization_areas: List[str] = Field(default=[], sa_column=Column(JSON))
expertise_levels: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
specialization_areas: list[str] = Field(default=[], sa_column=Column(JSON))
expertise_levels: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Performance history
performance_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
improvement_trends: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
performance_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
improvement_trends: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Benchmarking
benchmark_scores: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
ranking_position: Optional[int] = None
percentile_rank: Optional[float] = None
benchmark_scores: dict[str, float] = Field(default={}, sa_column=Column(JSON))
ranking_position: int | None = None
percentile_rank: float | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_assessed: Optional[datetime] = None
last_assessed: datetime | None = None
# Additional data
profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_notes: str = Field(default="", max_length=1000)
class MetaLearningModel(SQLModel, table=True):
"""Meta-learning models and configurations"""
__tablename__ = "meta_learning_models"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"meta_{uuid4().hex[:8]}", primary_key=True)
model_id: str = Field(unique=True, index=True)
# Model identification
model_name: str = Field(max_length=100)
model_type: str = Field(default="meta_learning")
model_version: str = Field(default="1.0.0")
# Learning configuration
base_algorithms: List[str] = Field(default=[], sa_column=Column(JSON))
base_algorithms: list[str] = Field(default=[], sa_column=Column(JSON))
meta_strategy: LearningStrategy
adaptation_targets: List[str] = Field(default=[], sa_column=Column(JSON))
adaptation_targets: list[str] = Field(default=[], sa_column=Column(JSON))
# Training data
training_tasks: List[str] = Field(default=[], sa_column=Column(JSON))
task_distributions: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
meta_features: List[str] = Field(default=[], sa_column=Column(JSON))
training_tasks: list[str] = Field(default=[], sa_column=Column(JSON))
task_distributions: dict[str, float] = Field(default={}, sa_column=Column(JSON))
meta_features: list[str] = Field(default=[], sa_column=Column(JSON))
# Model performance
meta_accuracy: float = Field(default=0.0, ge=0, le=1.0)
adaptation_speed: float = Field(default=0.0, ge=0, le=1.0)
generalization_ability: float = Field(default=0.0, ge=0, le=1.0)
# Resource requirements
training_time: Optional[float] = None # hours
computational_cost: Optional[float] = None # cost units
memory_requirement: Optional[float] = None # GB
gpu_requirement: Optional[bool] = Field(default=False)
training_time: float | None = None # hours
computational_cost: float | None = None # cost units
memory_requirement: float | None = None # GB
gpu_requirement: bool | None = Field(default=False)
# Deployment status
status: str = Field(default="training") # training, ready, deployed, deprecated
deployment_count: int = Field(default=0)
success_rate: float = Field(default=0.0, ge=0, le=1.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
trained_at: Optional[datetime] = None
deployed_at: Optional[datetime] = None
trained_at: datetime | None = None
deployed_at: datetime | None = None
# Additional data
model_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_logs: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
model_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_logs: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class ResourceAllocation(SQLModel, table=True):
"""Resource allocation and optimization records"""
__tablename__ = "resource_allocations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"alloc_{uuid4().hex[:8]}", primary_key=True)
allocation_id: str = Field(unique=True, index=True)
# Allocation details
agent_id: str = Field(index=True)
task_id: Optional[str] = None
session_id: Optional[str] = None
task_id: str | None = None
session_id: str | None = None
# Resource requirements
cpu_cores: float = Field(default=1.0)
memory_gb: float = Field(default=2.0)
@@ -180,302 +183,302 @@ class ResourceAllocation(SQLModel, table=True):
gpu_memory_gb: float = Field(default=0.0)
storage_gb: float = Field(default=10.0)
network_bandwidth: float = Field(default=100.0) # Mbps
# Optimization targets
optimization_target: OptimizationTarget
priority_level: str = Field(default="normal") # low, normal, high, critical
# Performance metrics
actual_performance: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
actual_performance: dict[str, float] = Field(default={}, sa_column=Column(JSON))
efficiency_score: float = Field(default=0.0, ge=0, le=1.0)
cost_efficiency: float = Field(default=0.0, ge=0, le=1.0)
# Allocation status
status: str = Field(default="pending") # pending, allocated, active, completed, failed
allocated_at: Optional[datetime] = None
started_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
allocated_at: datetime | None = None
started_at: datetime | None = None
completed_at: datetime | None = None
# Optimization results
optimization_applied: bool = Field(default=False)
optimization_savings: float = Field(default=0.0)
performance_improvement: float = Field(default=0.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow())
# Additional data
allocation_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
resource_utilization: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
allocation_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
resource_utilization: dict[str, float] = Field(default={}, sa_column=Column(JSON))
class PerformanceOptimization(SQLModel, table=True):
"""Performance optimization records and results"""
__tablename__ = "performance_optimizations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"opt_{uuid4().hex[:8]}", primary_key=True)
optimization_id: str = Field(unique=True, index=True)
# Optimization details
agent_id: str = Field(index=True)
optimization_type: str = Field(max_length=50) # resource, algorithm, hyperparameter, architecture
target_metric: PerformanceMetric
# Before optimization
baseline_performance: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
baseline_resources: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
baseline_performance: dict[str, float] = Field(default={}, sa_column=Column(JSON))
baseline_resources: dict[str, float] = Field(default={}, sa_column=Column(JSON))
baseline_cost: float = Field(default=0.0)
# Optimization configuration
optimization_parameters: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
optimization_parameters: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
optimization_algorithm: str = Field(default="auto")
search_space: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
search_space: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# After optimization
optimized_performance: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
optimized_resources: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
optimized_performance: dict[str, float] = Field(default={}, sa_column=Column(JSON))
optimized_resources: dict[str, float] = Field(default={}, sa_column=Column(JSON))
optimized_cost: float = Field(default=0.0)
# Improvement metrics
performance_improvement: float = Field(default=0.0)
resource_savings: float = Field(default=0.0)
cost_savings: float = Field(default=0.0)
overall_efficiency_gain: float = Field(default=0.0)
# Optimization process
optimization_duration: Optional[float] = None # seconds
optimization_duration: float | None = None # seconds
iterations_required: int = Field(default=0)
convergence_achieved: bool = Field(default=False)
# Status and deployment
status: str = Field(default="pending") # pending, running, completed, failed, deployed
applied_at: Optional[datetime] = None
applied_at: datetime | None = None
rollback_available: bool = Field(default=True)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
completed_at: Optional[datetime] = None
completed_at: datetime | None = None
# Additional data
optimization_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_logs: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
optimization_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_logs: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class AgentCapability(SQLModel, table=True):
"""Agent capabilities and skill assessments"""
__tablename__ = "agent_capabilities"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"cap_{uuid4().hex[:8]}", primary_key=True)
capability_id: str = Field(unique=True, index=True)
# Capability details
agent_id: str = Field(index=True)
capability_name: str = Field(max_length=100)
capability_type: str = Field(max_length=50) # cognitive, creative, analytical, technical
domain_area: str = Field(max_length=50)
# Skill level assessment
skill_level: float = Field(default=0.0, ge=0, le=10.0)
proficiency_score: float = Field(default=0.0, ge=0, le=1.0)
experience_years: float = Field(default=0.0)
# Capability metrics
performance_metrics: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
performance_metrics: dict[str, float] = Field(default={}, sa_column=Column(JSON))
success_rate: float = Field(default=0.0, ge=0, le=1.0)
average_quality: float = Field(default=0.0, ge=0, le=5.0)
# Learning and adaptation
learning_rate: float = Field(default=0.0, ge=0, le=1.0)
adaptation_speed: float = Field(default=0.0, ge=0, le=1.0)
knowledge_retention: float = Field(default=0.0, ge=0, le=1.0)
# Specialization
specializations: List[str] = Field(default=[], sa_column=Column(JSON))
sub_capabilities: List[str] = Field(default=[], sa_column=Column(JSON))
tool_proficiency: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
specializations: list[str] = Field(default=[], sa_column=Column(JSON))
sub_capabilities: list[str] = Field(default=[], sa_column=Column(JSON))
tool_proficiency: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Development history
acquired_at: datetime = Field(default_factory=datetime.utcnow)
last_improved: Optional[datetime] = None
last_improved: datetime | None = None
improvement_count: int = Field(default=0)
# Certification and validation
certified: bool = Field(default=False)
certification_level: Optional[str] = None
last_validated: Optional[datetime] = None
certification_level: str | None = None
last_validated: datetime | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional data
capability_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
capability_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class FusionModel(SQLModel, table=True):
"""Multi-modal agent fusion models"""
__tablename__ = "fusion_models"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"fusion_{uuid4().hex[:8]}", primary_key=True)
fusion_id: str = Field(unique=True, index=True)
# Model identification
model_name: str = Field(max_length=100)
fusion_type: str = Field(max_length=50) # ensemble, hybrid, multi_modal, cross_domain
model_version: str = Field(default="1.0.0")
# Component models
base_models: List[str] = Field(default=[], sa_column=Column(JSON))
model_weights: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
base_models: list[str] = Field(default=[], sa_column=Column(JSON))
model_weights: dict[str, float] = Field(default={}, sa_column=Column(JSON))
fusion_strategy: str = Field(default="weighted_average")
# Input modalities
input_modalities: List[str] = Field(default=[], sa_column=Column(JSON))
modality_weights: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
input_modalities: list[str] = Field(default=[], sa_column=Column(JSON))
modality_weights: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Performance metrics
fusion_performance: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
fusion_performance: dict[str, float] = Field(default={}, sa_column=Column(JSON))
synergy_score: float = Field(default=0.0, ge=0, le=1.0)
robustness_score: float = Field(default=0.0, ge=0, le=1.0)
# Resource requirements
computational_complexity: str = Field(default="medium") # low, medium, high, very_high
memory_requirement: float = Field(default=0.0) # GB
inference_time: float = Field(default=0.0) # seconds
# Training data
training_datasets: List[str] = Field(default=[], sa_column=Column(JSON))
data_requirements: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_datasets: list[str] = Field(default=[], sa_column=Column(JSON))
data_requirements: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Deployment status
status: str = Field(default="training") # training, ready, deployed, deprecated
deployment_count: int = Field(default=0)
performance_stability: float = Field(default=0.0, ge=0, le=1.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
trained_at: Optional[datetime] = None
deployed_at: Optional[datetime] = None
trained_at: datetime | None = None
deployed_at: datetime | None = None
# Additional data
fusion_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_logs: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
fusion_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_logs: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class ReinforcementLearningConfig(SQLModel, table=True):
"""Reinforcement learning configurations and policies"""
__tablename__ = "rl_configurations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"rl_{uuid4().hex[:8]}", primary_key=True)
config_id: str = Field(unique=True, index=True)
# Configuration details
agent_id: str = Field(index=True)
environment_type: str = Field(max_length=50)
algorithm: str = Field(default="ppo") # ppo, a2c, dqn, sac, td3
# Learning parameters
learning_rate: float = Field(default=0.001)
discount_factor: float = Field(default=0.99)
exploration_rate: float = Field(default=0.1)
batch_size: int = Field(default=64)
# Network architecture
network_layers: List[int] = Field(default=[256, 256, 128], sa_column=Column(JSON))
activation_functions: List[str] = Field(default=["relu", "relu", "tanh"], sa_column=Column(JSON))
network_layers: list[int] = Field(default=[256, 256, 128], sa_column=Column(JSON))
activation_functions: list[str] = Field(default=["relu", "relu", "tanh"], sa_column=Column(JSON))
# Training configuration
max_episodes: int = Field(default=1000)
max_steps_per_episode: int = Field(default=1000)
save_frequency: int = Field(default=100)
# Performance metrics
reward_history: List[float] = Field(default=[], sa_column=Column(JSON))
success_rate_history: List[float] = Field(default=[], sa_column=Column(JSON))
convergence_episode: Optional[int] = None
reward_history: list[float] = Field(default=[], sa_column=Column(JSON))
success_rate_history: list[float] = Field(default=[], sa_column=Column(JSON))
convergence_episode: int | None = None
# Policy details
policy_type: str = Field(default="stochastic") # stochastic, deterministic
action_space: List[str] = Field(default=[], sa_column=Column(JSON))
state_space: List[str] = Field(default=[], sa_column=Column(JSON))
action_space: list[str] = Field(default=[], sa_column=Column(JSON))
state_space: list[str] = Field(default=[], sa_column=Column(JSON))
# Status and deployment
status: str = Field(default="training") # training, ready, deployed, deprecated
training_progress: float = Field(default=0.0, ge=0, le=1.0)
deployment_performance: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
deployment_performance: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
trained_at: Optional[datetime] = None
deployed_at: Optional[datetime] = None
trained_at: datetime | None = None
deployed_at: datetime | None = None
# Additional data
rl_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_logs: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
rl_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
training_logs: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class CreativeCapability(SQLModel, table=True):
"""Creative and specialized AI capabilities"""
__tablename__ = "creative_capabilities"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"creative_{uuid4().hex[:8]}", primary_key=True)
capability_id: str = Field(unique=True, index=True)
# Capability details
agent_id: str = Field(index=True)
creative_domain: str = Field(max_length=50) # art, music, writing, design, innovation
capability_type: str = Field(max_length=50) # generative, compositional, analytical, innovative
# Creative metrics
originality_score: float = Field(default=0.0, ge=0, le=1.0)
novelty_score: float = Field(default=0.0, ge=0, le=1.0)
aesthetic_quality: float = Field(default=0.0, ge=0, le=5.0)
coherence_score: float = Field(default=0.0, ge=0, le=1.0)
# Generation capabilities
generation_models: List[str] = Field(default=[], sa_column=Column(JSON))
generation_models: list[str] = Field(default=[], sa_column=Column(JSON))
style_variety: int = Field(default=1)
output_quality: float = Field(default=0.0, ge=0, le=5.0)
# Learning and adaptation
creative_learning_rate: float = Field(default=0.0, ge=0, le=1.0)
style_adaptation: float = Field(default=0.0, ge=0, le=1.0)
cross_domain_transfer: float = Field(default=0.0, ge=0, le=1.0)
# Specialization
creative_specializations: List[str] = Field(default=[], sa_column=Column(JSON))
tool_proficiency: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
domain_knowledge: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
creative_specializations: list[str] = Field(default=[], sa_column=Column(JSON))
tool_proficiency: dict[str, float] = Field(default={}, sa_column=Column(JSON))
domain_knowledge: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Performance tracking
creations_generated: int = Field(default=0)
user_ratings: List[float] = Field(default=[], sa_column=Column(JSON))
expert_evaluations: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
user_ratings: list[float] = Field(default=[], sa_column=Column(JSON))
expert_evaluations: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Status and certification
status: str = Field(default="developing") # developing, ready, certified, deprecated
certification_level: Optional[str] = None
last_evaluation: Optional[datetime] = None
certification_level: str | None = None
last_evaluation: datetime | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional data
creative_profile_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
portfolio_samples: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
creative_profile_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
portfolio_samples: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))

122
apps/coordinator-api/src/app/domain/agent_portfolio.py
View File

@@ -6,30 +6,28 @@ Domain models for agent portfolio management, trading strategies, and risk asses
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Dict, List, Optional
from uuid import uuid4
from datetime import datetime, timedelta
from enum import StrEnum
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class StrategyType(str, Enum):
class StrategyType(StrEnum):
CONSERVATIVE = "conservative"
BALANCED = "balanced"
AGGRESSIVE = "aggressive"
DYNAMIC = "dynamic"
class TradeStatus(str, Enum):
class TradeStatus(StrEnum):
PENDING = "pending"
EXECUTED = "executed"
FAILED = "failed"
CANCELLED = "cancelled"
class RiskLevel(str, Enum):
class RiskLevel(StrEnum):
LOW = "low"
MEDIUM = "medium"
HIGH = "high"
@@ -38,31 +36,33 @@ class RiskLevel(str, Enum):
class PortfolioStrategy(SQLModel, table=True):
"""Trading strategy configuration for agent portfolios"""
__tablename__ = "portfolio_strategy"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
name: str = Field(index=True)
strategy_type: StrategyType = Field(index=True)
target_allocations: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
target_allocations: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
max_drawdown: float = Field(default=20.0) # Maximum drawdown percentage
rebalance_frequency: int = Field(default=86400) # Rebalancing frequency in seconds
volatility_threshold: float = Field(default=15.0) # Volatility threshold for rebalancing
is_active: bool = Field(default=True, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: portfolios: List["AgentPortfolio"] = Relationship(back_populates="strategy")
class AgentPortfolio(SQLModel, table=True):
"""Portfolio managed by an autonomous agent"""
__tablename__ = "agent_portfolio"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
agent_address: str = Field(index=True)
strategy_id: int = Field(foreign_key="portfolio_strategy.id", index=True)
contract_portfolio_id: Optional[str] = Field(default=None, index=True)
contract_portfolio_id: str | None = Field(default=None, index=True)
initial_capital: float = Field(default=0.0)
total_value: float = Field(default=0.0)
risk_score: float = Field(default=0.0) # Risk score (0-100)
@@ -71,7 +71,7 @@ class AgentPortfolio(SQLModel, table=True):
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_rebalance: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: strategy: PortfolioStrategy = Relationship(back_populates="portfolios")
# DISABLED: assets: List["PortfolioAsset"] = Relationship(back_populates="portfolio")
@@ -81,9 +81,10 @@ class AgentPortfolio(SQLModel, table=True):
class PortfolioAsset(SQLModel, table=True):
"""Asset holdings within a portfolio"""
__tablename__ = "portfolio_asset"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
token_symbol: str = Field(index=True)
token_address: str = Field(index=True)
@@ -94,16 +95,17 @@ class PortfolioAsset(SQLModel, table=True):
unrealized_pnl: float = Field(default=0.0) # Unrealized profit/loss
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: portfolio: AgentPortfolio = Relationship(back_populates="assets")
class PortfolioTrade(SQLModel, table=True):
"""Trade executed within a portfolio"""
__tablename__ = "portfolio_trade"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
sell_token: str = Field(index=True)
buy_token: str = Field(index=True)
@@ -112,19 +114,20 @@ class PortfolioTrade(SQLModel, table=True):
price: float = Field(default=0.0)
fee_amount: float = Field(default=0.0)
status: TradeStatus = Field(default=TradeStatus.PENDING, index=True)
transaction_hash: Optional[str] = Field(default=None, index=True)
executed_at: Optional[datetime] = Field(default=None, index=True)
transaction_hash: str | None = Field(default=None, index=True)
executed_at: datetime | None = Field(default=None, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
# Relationships
# DISABLED: portfolio: AgentPortfolio = Relationship(back_populates="trades")
class RiskMetrics(SQLModel, table=True):
"""Risk assessment metrics for a portfolio"""
__tablename__ = "risk_metrics"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
volatility: float = Field(default=0.0) # Portfolio volatility
max_drawdown: float = Field(default=0.0) # Maximum drawdown
@@ -133,21 +136,22 @@ class RiskMetrics(SQLModel, table=True):
alpha: float = Field(default=0.0) # Alpha coefficient
var_95: float = Field(default=0.0) # Value at Risk at 95% confidence
var_99: float = Field(default=0.0) # Value at Risk at 99% confidence
correlation_matrix: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
correlation_matrix: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
risk_level: RiskLevel = Field(default=RiskLevel.LOW, index=True)
overall_risk_score: float = Field(default=0.0) # Overall risk score (0-100)
stress_test_results: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
stress_test_results: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: portfolio: AgentPortfolio = Relationship(back_populates="risk_metrics")
class RebalanceHistory(SQLModel, table=True):
"""History of portfolio rebalancing events"""
__tablename__ = "rebalance_history"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
trigger_reason: str = Field(index=True) # Reason for rebalancing
pre_rebalance_value: float = Field(default=0.0)
@@ -160,9 +164,10 @@ class RebalanceHistory(SQLModel, table=True):
class PerformanceMetrics(SQLModel, table=True):
"""Performance metrics for portfolios"""
__tablename__ = "performance_metrics"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
period: str = Field(index=True) # Performance period (1d, 7d, 30d, etc.)
total_return: float = Field(default=0.0) # Total return percentage
@@ -186,25 +191,27 @@ class PerformanceMetrics(SQLModel, table=True):
class PortfolioAlert(SQLModel, table=True):
"""Alerts for portfolio events"""
__tablename__ = "portfolio_alert"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
alert_type: str = Field(index=True) # Type of alert
severity: str = Field(index=True) # Severity level
message: str = Field(default="")
meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
is_acknowledged: bool = Field(default=False, index=True)
acknowledged_at: Optional[datetime] = Field(default=None)
acknowledged_at: datetime | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
resolved_at: Optional[datetime] = Field(default=None)
resolved_at: datetime | None = Field(default=None)
class StrategySignal(SQLModel, table=True):
"""Trading signals generated by strategies"""
__tablename__ = "strategy_signal"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
strategy_id: int = Field(foreign_key="portfolio_strategy.id", index=True)
signal_type: str = Field(index=True) # BUY, SELL, HOLD
token_symbol: str = Field(index=True)
@@ -213,40 +220,42 @@ class StrategySignal(SQLModel, table=True):
stop_loss: float = Field(default=0.0) # Stop loss price
time_horizon: str = Field(default="1d") # Time horizon
reasoning: str = Field(default="") # Signal reasoning
meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
is_executed: bool = Field(default=False, index=True)
executed_at: Optional[datetime] = Field(default=None)
executed_at: datetime | None = Field(default=None)
expires_at: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(hours=24))
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
class PortfolioSnapshot(SQLModel, table=True):
"""Daily snapshot of portfolio state"""
__tablename__ = "portfolio_snapshot"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
snapshot_date: datetime = Field(index=True)
total_value: float = Field(default=0.0)
cash_balance: float = Field(default=0.0)
asset_count: int = Field(default=0)
top_holdings: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
sector_allocation: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
geographic_allocation: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
risk_metrics: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
performance_metrics: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
top_holdings: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
sector_allocation: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
geographic_allocation: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
risk_metrics: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
performance_metrics: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
class TradingRule(SQLModel, table=True):
"""Trading rules and constraints for portfolios"""
__tablename__ = "trading_rule"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
portfolio_id: int = Field(foreign_key="agent_portfolio.id", index=True)
rule_type: str = Field(index=True) # Type of rule
rule_name: str = Field(index=True)
parameters: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
parameters: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
is_active: bool = Field(default=True, index=True)
priority: int = Field(default=0) # Rule priority (higher = more important)
created_at: datetime = Field(default_factory=datetime.utcnow)
@@ -255,13 +264,14 @@ class TradingRule(SQLModel, table=True):
class MarketCondition(SQLModel, table=True):
"""Market conditions affecting portfolio decisions"""
__tablename__ = "market_condition"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
condition_type: str = Field(index=True) # BULL, BEAR, SIDEWAYS, VOLATILE
market_index: str = Field(index=True) # Market index (SPY, QQQ, etc.)
confidence: float = Field(default=0.0) # Confidence in condition
indicators: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
indicators: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
sentiment_score: float = Field(default=0.0) # Market sentiment score
volatility_index: float = Field(default=0.0) # VIX or similar
trend_strength: float = Field(default=0.0) # Trend strength

132
apps/coordinator-api/src/app/domain/amm.py
View File

@@ -7,29 +7,27 @@ Domain models for automated market making, liquidity pools, and swap transaction
from __future__ import annotations
from datetime import datetime, timedelta
from enum import Enum
from typing import Dict, List, Optional
from uuid import uuid4
from enum import StrEnum
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class PoolStatus(str, Enum):
class PoolStatus(StrEnum):
ACTIVE = "active"
INACTIVE = "inactive"
PAUSED = "paused"
MAINTENANCE = "maintenance"
class SwapStatus(str, Enum):
class SwapStatus(StrEnum):
PENDING = "pending"
EXECUTED = "executed"
FAILED = "failed"
CANCELLED = "cancelled"
class LiquidityPositionStatus(str, Enum):
class LiquidityPositionStatus(StrEnum):
ACTIVE = "active"
WITHDRAWN = "withdrawn"
PENDING = "pending"
@@ -37,9 +35,10 @@ class LiquidityPositionStatus(str, Enum):
class LiquidityPool(SQLModel, table=True):
"""Liquidity pool for automated market making"""
__tablename__ = "liquidity_pool"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
contract_pool_id: str = Field(index=True) # Contract pool ID
token_a: str = Field(index=True) # Token A address
token_b: str = Field(index=True) # Token B address
@@ -62,8 +61,8 @@ class LiquidityPool(SQLModel, table=True):
created_by: str = Field(index=True) # Creator address
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_trade_time: Optional[datetime] = Field(default=None)
last_trade_time: datetime | None = Field(default=None)
# Relationships
# DISABLED: positions: List["LiquidityPosition"] = Relationship(back_populates="pool")
# DISABLED: swaps: List["SwapTransaction"] = Relationship(back_populates="pool")
@@ -73,9 +72,10 @@ class LiquidityPool(SQLModel, table=True):
class LiquidityPosition(SQLModel, table=True):
"""Liquidity provider position in a pool"""
__tablename__ = "liquidity_position"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
provider_address: str = Field(index=True)
liquidity_amount: float = Field(default=0.0) # Amount of liquidity tokens
@@ -90,9 +90,9 @@ class LiquidityPosition(SQLModel, table=True):
status: LiquidityPositionStatus = Field(default=LiquidityPositionStatus.ACTIVE, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_deposit: Optional[datetime] = Field(default=None)
last_withdrawal: Optional[datetime] = Field(default=None)
last_deposit: datetime | None = Field(default=None)
last_withdrawal: datetime | None = Field(default=None)
# Relationships
# DISABLED: pool: LiquidityPool = Relationship(back_populates="positions")
# DISABLED: fee_claims: List["FeeClaim"] = Relationship(back_populates="position")
@@ -100,9 +100,10 @@ class LiquidityPosition(SQLModel, table=True):
class SwapTransaction(SQLModel, table=True):
"""Swap transaction executed in a pool"""
__tablename__ = "swap_transaction"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
user_address: str = Field(index=True)
token_in: str = Field(index=True)
@@ -115,23 +116,24 @@ class SwapTransaction(SQLModel, table=True):
fee_amount: float = Field(default=0.0) # Fee amount
fee_percentage: float = Field(default=0.0) # Applied fee percentage
status: SwapStatus = Field(default=SwapStatus.PENDING, index=True)
transaction_hash: Optional[str] = Field(default=None, index=True)
block_number: Optional[int] = Field(default=None)
gas_used: Optional[int] = Field(default=None)
gas_price: Optional[float] = Field(default=None)
executed_at: Optional[datetime] = Field(default=None, index=True)
transaction_hash: str | None = Field(default=None, index=True)
block_number: int | None = Field(default=None)
gas_used: int | None = Field(default=None)
gas_price: float | None = Field(default=None)
executed_at: datetime | None = Field(default=None, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
deadline: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(minutes=20))
# Relationships
# DISABLED: pool: LiquidityPool = Relationship(back_populates="swaps")
class PoolMetrics(SQLModel, table=True):
"""Historical metrics for liquidity pools"""
__tablename__ = "pool_metrics"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
timestamp: datetime = Field(index=True)
total_volume_24h: float = Field(default=0.0)
@@ -146,18 +148,19 @@ class PoolMetrics(SQLModel, table=True):
average_trade_size: float = Field(default=0.0) # Average trade size
impermanent_loss_24h: float = Field(default=0.0) # 24h impermanent loss
liquidity_provider_count: int = Field(default=0) # Number of liquidity providers
top_lps: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON)) # Top LPs by share
top_lps: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON)) # Top LPs by share
created_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: pool: LiquidityPool = Relationship(back_populates="metrics")
class FeeStructure(SQLModel, table=True):
"""Fee structure for liquidity pools"""
__tablename__ = "fee_structure"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
base_fee_percentage: float = Field(default=0.3) # Base fee percentage
current_fee_percentage: float = Field(default=0.3) # Current fee percentage
@@ -173,9 +176,10 @@ class FeeStructure(SQLModel, table=True):
class IncentiveProgram(SQLModel, table=True):
"""Incentive program for liquidity providers"""
__tablename__ = "incentive_program"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
program_name: str = Field(index=True)
reward_token: str = Field(index=True) # Reward token address
@@ -192,7 +196,7 @@ class IncentiveProgram(SQLModel, table=True):
end_time: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(days=30))
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: pool: LiquidityPool = Relationship(back_populates="incentives")
# DISABLED: rewards: List["LiquidityReward"] = Relationship(back_populates="program")
@@ -200,9 +204,10 @@ class IncentiveProgram(SQLModel, table=True):
class LiquidityReward(SQLModel, table=True):
"""Reward earned by liquidity providers"""
__tablename__ = "liquidity_reward"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
program_id: int = Field(foreign_key="incentive_program.id", index=True)
position_id: int = Field(foreign_key="liquidity_position.id", index=True)
provider_address: str = Field(index=True)
@@ -211,12 +216,12 @@ class LiquidityReward(SQLModel, table=True):
liquidity_share: float = Field(default=0.0) # Share of pool liquidity
time_weighted_share: float = Field(default=0.0) # Time-weighted share
is_claimed: bool = Field(default=False, index=True)
claimed_at: Optional[datetime] = Field(default=None)
claim_transaction_hash: Optional[str] = Field(default=None)
vesting_start: Optional[datetime] = Field(default=None)
vesting_end: Optional[datetime] = Field(default=None)
claimed_at: datetime | None = Field(default=None)
claim_transaction_hash: str | None = Field(default=None)
vesting_start: datetime | None = Field(default=None)
vesting_end: datetime | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
# Relationships
# DISABLED: program: IncentiveProgram = Relationship(back_populates="rewards")
# DISABLED: position: LiquidityPosition = Relationship(back_populates="fee_claims")
@@ -224,9 +229,10 @@ class LiquidityReward(SQLModel, table=True):
class FeeClaim(SQLModel, table=True):
"""Fee claim by liquidity providers"""
__tablename__ = "fee_claim"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
position_id: int = Field(foreign_key="liquidity_position.id", index=True)
provider_address: str = Field(index=True)
fee_amount: float = Field(default=0.0)
@@ -235,19 +241,20 @@ class FeeClaim(SQLModel, table=True):
claim_period_end: datetime = Field(index=True)
liquidity_share: float = Field(default=0.0) # Share of pool liquidity
is_claimed: bool = Field(default=False, index=True)
claimed_at: Optional[datetime] = Field(default=None)
claim_transaction_hash: Optional[str] = Field(default=None)
claimed_at: datetime | None = Field(default=None)
claim_transaction_hash: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
# Relationships
# DISABLED: position: LiquidityPosition = Relationship(back_populates="fee_claims")
class PoolConfiguration(SQLModel, table=True):
"""Configuration settings for liquidity pools"""
__tablename__ = "pool_configuration"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
config_key: str = Field(index=True)
config_value: str = Field(default="")
@@ -259,31 +266,33 @@ class PoolConfiguration(SQLModel, table=True):
class PoolAlert(SQLModel, table=True):
"""Alerts for pool events and conditions"""
__tablename__ = "pool_alert"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
alert_type: str = Field(index=True) # LOW_LIQUIDITY, HIGH_VOLATILITY, etc.
severity: str = Field(index=True) # LOW, MEDIUM, HIGH, CRITICAL
title: str = Field(default="")
message: str = Field(default="")
meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
threshold_value: float = Field(default=0.0) # Threshold that triggered alert
current_value: float = Field(default=0.0) # Current value
is_acknowledged: bool = Field(default=False, index=True)
acknowledged_by: Optional[str] = Field(default=None)
acknowledged_at: Optional[datetime] = Field(default=None)
acknowledged_by: str | None = Field(default=None)
acknowledged_at: datetime | None = Field(default=None)
is_resolved: bool = Field(default=False, index=True)
resolved_at: Optional[datetime] = Field(default=None)
resolved_at: datetime | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
expires_at: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(hours=24))
class PoolSnapshot(SQLModel, table=True):
"""Daily snapshot of pool state"""
__tablename__ = "pool_snapshot"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
pool_id: int = Field(foreign_key="liquidity_pool.id", index=True)
snapshot_date: datetime = Field(index=True)
reserve_a: float = Field(default=0.0)
@@ -306,9 +315,10 @@ class PoolSnapshot(SQLModel, table=True):
class ArbitrageOpportunity(SQLModel, table=True):
"""Arbitrage opportunities across pools"""
__tablename__ = "arbitrage_opportunity"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
token_a: str = Field(index=True)
token_b: str = Field(index=True)
pool_1_id: int = Field(foreign_key="liquidity_pool.id", index=True)
@@ -322,8 +332,8 @@ class ArbitrageOpportunity(SQLModel, table=True):
required_amount: float = Field(default=0.0) # Amount needed for arbitrage
confidence: float = Field(default=0.0) # Confidence in opportunity
is_executed: bool = Field(default=False, index=True)
executed_at: Optional[datetime] = Field(default=None)
execution_tx_hash: Optional[str] = Field(default=None)
actual_profit: Optional[float] = Field(default=None)
executed_at: datetime | None = Field(default=None)
execution_tx_hash: str | None = Field(default=None)
actual_profit: float | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
expires_at: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(minutes=5))

349
apps/coordinator-api/src/app/domain/analytics.py
View File

@@ -3,17 +3,17 @@ Marketplace Analytics Domain Models
Implements SQLModel definitions for analytics, insights, and reporting
"""
from datetime import datetime, timedelta
from typing import Optional, Dict, List, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Float, Integer, Text
from sqlmodel import JSON, Column, Field, SQLModel
class AnalyticsPeriod(str, Enum):
class AnalyticsPeriod(StrEnum):
"""Analytics period enumeration"""
REALTIME = "realtime"
HOURLY = "hourly"
DAILY = "daily"
@@ -23,8 +23,9 @@ class AnalyticsPeriod(str, Enum):
YEARLY = "yearly"
class MetricType(str, Enum):
class MetricType(StrEnum):
"""Metric type enumeration"""
VOLUME = "volume"
COUNT = "count"
AVERAGE = "average"
@@ -34,8 +35,9 @@ class MetricType(str, Enum):
VALUE = "value"
class InsightType(str, Enum):
class InsightType(StrEnum):
"""Insight type enumeration"""
TREND = "trend"
ANOMALY = "anomaly"
OPPORTUNITY = "opportunity"
@@ -44,8 +46,9 @@ class InsightType(str, Enum):
RECOMMENDATION = "recommendation"
class ReportType(str, Enum):
class ReportType(StrEnum):
"""Report type enumeration"""
MARKET_OVERVIEW = "market_overview"
AGENT_PERFORMANCE = "agent_performance"
ECONOMIC_ANALYSIS = "economic_analysis"
@@ -56,385 +59,385 @@ class ReportType(str, Enum):
class MarketMetric(SQLModel, table=True):
"""Market metrics and KPIs"""
__tablename__ = "market_metrics"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"metric_{uuid4().hex[:8]}", primary_key=True)
metric_name: str = Field(index=True)
metric_type: MetricType
period_type: AnalyticsPeriod
# Metric values
value: float = Field(default=0.0)
previous_value: Optional[float] = None
change_percentage: Optional[float] = None
previous_value: float | None = None
change_percentage: float | None = None
# Contextual data
unit: str = Field(default="")
category: str = Field(default="general")
subcategory: str = Field(default="")
# Geographic and temporal context
geographic_region: Optional[str] = None
agent_tier: Optional[str] = None
trade_type: Optional[str] = None
geographic_region: str | None = None
agent_tier: str | None = None
trade_type: str | None = None
# Metadata
metric_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
metric_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Timestamps
recorded_at: datetime = Field(default_factory=datetime.utcnow)
period_start: datetime
period_end: datetime
# Additional data
breakdown: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
comparisons: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
breakdown: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
comparisons: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class MarketInsight(SQLModel, table=True):
"""Market insights and analysis"""
__tablename__ = "market_insights"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"insight_{uuid4().hex[:8]}", primary_key=True)
insight_type: InsightType
title: str = Field(max_length=200)
description: str = Field(default="", max_length=1000)
# Insight data
confidence_score: float = Field(default=0.0, ge=0, le=1.0)
impact_level: str = Field(default="medium") # low, medium, high, critical
urgency_level: str = Field(default="normal") # low, normal, high, urgent
# Related metrics and context
related_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
affected_entities: List[str] = Field(default=[], sa_column=Column(JSON))
related_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
affected_entities: list[str] = Field(default=[], sa_column=Column(JSON))
time_horizon: str = Field(default="short_term") # immediate, short_term, medium_term, long_term
# Analysis details
analysis_method: str = Field(default="statistical")
data_sources: List[str] = Field(default=[], sa_column=Column(JSON))
assumptions: List[str] = Field(default=[], sa_column=Column(JSON))
data_sources: list[str] = Field(default=[], sa_column=Column(JSON))
assumptions: list[str] = Field(default=[], sa_column=Column(JSON))
# Recommendations and actions
recommendations: List[str] = Field(default=[], sa_column=Column(JSON))
suggested_actions: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
recommendations: list[str] = Field(default=[], sa_column=Column(JSON))
suggested_actions: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Status and tracking
status: str = Field(default="active") # active, resolved, expired
acknowledged_by: Optional[str] = None
acknowledged_at: Optional[datetime] = None
resolved_by: Optional[str] = None
resolved_at: Optional[datetime] = None
acknowledged_by: str | None = None
acknowledged_at: datetime | None = None
resolved_by: str | None = None
resolved_at: datetime | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
# Additional data
insight_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
visualization_config: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
insight_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
visualization_config: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class AnalyticsReport(SQLModel, table=True):
"""Generated analytics reports"""
__tablename__ = "analytics_reports"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"report_{uuid4().hex[:8]}", primary_key=True)
report_id: str = Field(unique=True, index=True)
# Report details
report_type: ReportType
title: str = Field(max_length=200)
description: str = Field(default="", max_length=1000)
# Report parameters
period_type: AnalyticsPeriod
start_date: datetime
end_date: datetime
filters: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
filters: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Report content
summary: str = Field(default="", max_length=2000)
key_findings: List[str] = Field(default=[], sa_column=Column(JSON))
recommendations: List[str] = Field(default=[], sa_column=Column(JSON))
key_findings: list[str] = Field(default=[], sa_column=Column(JSON))
recommendations: list[str] = Field(default=[], sa_column=Column(JSON))
# Report data
data_sections: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
charts: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
tables: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
data_sections: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
charts: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
tables: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Generation details
generated_by: str = Field(default="system") # system, user, scheduled
generation_time: float = Field(default=0.0) # seconds
data_points_analyzed: int = Field(default=0)
# Status and delivery
status: str = Field(default="generated") # generating, generated, failed, delivered
delivery_method: str = Field(default="api") # api, email, dashboard
recipients: List[str] = Field(default=[], sa_column=Column(JSON))
recipients: list[str] = Field(default=[], sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
generated_at: datetime = Field(default_factory=datetime.utcnow)
delivered_at: Optional[datetime] = None
delivered_at: datetime | None = None
# Additional data
report_metric_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
template_used: Optional[str] = None
report_metric_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
template_used: str | None = None
class DashboardConfig(SQLModel, table=True):
"""Analytics dashboard configurations"""
__tablename__ = "dashboard_configs"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"dashboard_{uuid4().hex[:8]}", primary_key=True)
dashboard_id: str = Field(unique=True, index=True)
# Dashboard details
name: str = Field(max_length=100)
description: str = Field(default="", max_length=500)
dashboard_type: str = Field(default="custom") # default, custom, executive, operational
# Layout and configuration
layout: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
widgets: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
filters: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
layout: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
widgets: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
filters: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Data sources and refresh
data_sources: List[str] = Field(default=[], sa_column=Column(JSON))
data_sources: list[str] = Field(default=[], sa_column=Column(JSON))
refresh_interval: int = Field(default=300) # seconds
auto_refresh: bool = Field(default=True)
# Access and permissions
owner_id: str = Field(index=True)
viewers: List[str] = Field(default=[], sa_column=Column(JSON))
editors: List[str] = Field(default=[], sa_column=Column(JSON))
viewers: list[str] = Field(default=[], sa_column=Column(JSON))
editors: list[str] = Field(default=[], sa_column=Column(JSON))
is_public: bool = Field(default=False)
# Status and versioning
status: str = Field(default="active") # active, inactive, archived
version: int = Field(default=1)
last_modified_by: Optional[str] = None
last_modified_by: str | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_viewed_at: Optional[datetime] = None
last_viewed_at: datetime | None = None
# Additional data
dashboard_settings: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
theme_config: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
dashboard_settings: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
theme_config: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class DataCollectionJob(SQLModel, table=True):
"""Data collection and processing jobs"""
__tablename__ = "data_collection_jobs"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"job_{uuid4().hex[:8]}", primary_key=True)
job_id: str = Field(unique=True, index=True)
# Job details
job_type: str = Field(max_length=50) # metrics_collection, insight_generation, report_generation
job_name: str = Field(max_length=100)
description: str = Field(default="", max_length=500)
# Job parameters
parameters: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
data_sources: List[str] = Field(default=[], sa_column=Column(JSON))
target_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
parameters: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
data_sources: list[str] = Field(default=[], sa_column=Column(JSON))
target_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
# Schedule and execution
schedule_type: str = Field(default="manual") # manual, scheduled, triggered
cron_expression: Optional[str] = None
next_run: Optional[datetime] = None
cron_expression: str | None = None
next_run: datetime | None = None
# Execution details
status: str = Field(default="pending") # pending, running, completed, failed, cancelled
progress: float = Field(default=0.0, ge=0, le=100.0)
started_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
started_at: datetime | None = None
completed_at: datetime | None = None
# Results and output
records_processed: int = Field(default=0)
records_generated: int = Field(default=0)
errors: List[str] = Field(default=[], sa_column=Column(JSON))
output_files: List[str] = Field(default=[], sa_column=Column(JSON))
errors: list[str] = Field(default=[], sa_column=Column(JSON))
output_files: list[str] = Field(default=[], sa_column=Column(JSON))
# Performance metrics
execution_time: float = Field(default=0.0) # seconds
memory_usage: float = Field(default=0.0) # MB
cpu_usage: float = Field(default=0.0) # percentage
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional data
job_metric_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
execution_log: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
job_metric_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
execution_log: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class AlertRule(SQLModel, table=True):
"""Analytics alert rules and notifications"""
__tablename__ = "alert_rules"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"alert_{uuid4().hex[:8]}", primary_key=True)
rule_id: str = Field(unique=True, index=True)
# Rule details
name: str = Field(max_length=100)
description: str = Field(default="", max_length=500)
rule_type: str = Field(default="threshold") # threshold, anomaly, trend, pattern
# Conditions and triggers
conditions: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
threshold_value: Optional[float] = None
conditions: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
threshold_value: float | None = None
comparison_operator: str = Field(default="greater_than") # greater_than, less_than, equals, contains
# Target metrics and entities
target_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
target_entities: List[str] = Field(default=[], sa_column=Column(JSON))
geographic_scope: List[str] = Field(default=[], sa_column=Column(JSON))
target_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
target_entities: list[str] = Field(default=[], sa_column=Column(JSON))
geographic_scope: list[str] = Field(default=[], sa_column=Column(JSON))
# Alert configuration
severity: str = Field(default="medium") # low, medium, high, critical
cooldown_period: int = Field(default=300) # seconds
auto_resolve: bool = Field(default=False)
resolve_conditions: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
resolve_conditions: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Notification settings
notification_channels: List[str] = Field(default=[], sa_column=Column(JSON))
notification_recipients: List[str] = Field(default=[], sa_column=Column(JSON))
notification_channels: list[str] = Field(default=[], sa_column=Column(JSON))
notification_recipients: list[str] = Field(default=[], sa_column=Column(JSON))
message_template: str = Field(default="", max_length=1000)
# Status and scheduling
status: str = Field(default="active") # active, inactive, disabled
created_by: str = Field(index=True)
last_triggered: Optional[datetime] = None
last_triggered: datetime | None = None
trigger_count: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional data
rule_metric_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
test_results: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
rule_metric_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
test_results: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class AnalyticsAlert(SQLModel, table=True):
"""Generated analytics alerts"""
__tablename__ = "analytics_alerts"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"alert_{uuid4().hex[:8]}", primary_key=True)
alert_id: str = Field(unique=True, index=True)
# Alert details
rule_id: str = Field(index=True)
alert_type: str = Field(max_length=50)
title: str = Field(max_length=200)
message: str = Field(default="", max_length=1000)
# Alert data
severity: str = Field(default="medium")
confidence: float = Field(default=0.0, ge=0, le=1.0)
impact_assessment: str = Field(default="", max_length=500)
# Trigger data
trigger_value: Optional[float] = None
threshold_value: Optional[float] = None
deviation_percentage: Optional[float] = None
affected_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
trigger_value: float | None = None
threshold_value: float | None = None
deviation_percentage: float | None = None
affected_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
# Context and entities
geographic_regions: List[str] = Field(default=[], sa_column=Column(JSON))
affected_agents: List[str] = Field(default=[], sa_column=Column(JSON))
time_period: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
geographic_regions: list[str] = Field(default=[], sa_column=Column(JSON))
affected_agents: list[str] = Field(default=[], sa_column=Column(JSON))
time_period: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Status and resolution
status: str = Field(default="active") # active, acknowledged, resolved, false_positive
acknowledged_by: Optional[str] = None
acknowledged_at: Optional[datetime] = None
resolved_by: Optional[str] = None
resolved_at: Optional[datetime] = None
acknowledged_by: str | None = None
acknowledged_at: datetime | None = None
resolved_by: str | None = None
resolved_at: datetime | None = None
resolution_notes: str = Field(default="", max_length=1000)
# Notifications
notifications_sent: List[str] = Field(default=[], sa_column=Column(JSON))
delivery_status: Dict[str, str] = Field(default={}, sa_column=Column(JSON))
notifications_sent: list[str] = Field(default=[], sa_column=Column(JSON))
delivery_status: dict[str, str] = Field(default={}, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
# Additional data
alert_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
related_insights: List[str] = Field(default=[], sa_column=Column(JSON))
alert_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
related_insights: list[str] = Field(default=[], sa_column=Column(JSON))
class UserPreference(SQLModel, table=True):
"""User analytics preferences and settings"""
__tablename__ = "user_preferences"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"pref_{uuid4().hex[:8]}", primary_key=True)
user_id: str = Field(index=True)
# Notification preferences
email_notifications: bool = Field(default=True)
alert_notifications: bool = Field(default=True)
report_notifications: bool = Field(default=False)
notification_frequency: str = Field(default="daily") # immediate, daily, weekly, monthly
# Dashboard preferences
default_dashboard: Optional[str] = None
default_dashboard: str | None = None
preferred_timezone: str = Field(default="UTC")
date_format: str = Field(default="YYYY-MM-DD")
time_format: str = Field(default="24h")
# Metric preferences
favorite_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
metric_units: Dict[str, str] = Field(default={}, sa_column=Column(JSON))
favorite_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
metric_units: dict[str, str] = Field(default={}, sa_column=Column(JSON))
default_period: AnalyticsPeriod = Field(default=AnalyticsPeriod.DAILY)
# Alert preferences
alert_severity_threshold: str = Field(default="medium") # low, medium, high, critical
quiet_hours: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
alert_channels: List[str] = Field(default=[], sa_column=Column(JSON))
quiet_hours: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
alert_channels: list[str] = Field(default=[], sa_column=Column(JSON))
# Report preferences
auto_subscribe_reports: List[str] = Field(default=[], sa_column=Column(JSON))
auto_subscribe_reports: list[str] = Field(default=[], sa_column=Column(JSON))
report_format: str = Field(default="json") # json, csv, pdf, html
include_charts: bool = Field(default=True)
# Privacy and security
data_retention_days: int = Field(default=90)
share_analytics: bool = Field(default=False)
anonymous_usage: bool = Field(default=False)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_login: Optional[datetime] = None
last_login: datetime | None = None
# Additional preferences
custom_settings: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
ui_preferences: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
custom_settings: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
ui_preferences: dict[str, Any] = Field(default={}, sa_column=Column(JSON))

60
apps/coordinator-api/src/app/domain/atomic_swap.py
View File

@@ -7,56 +7,58 @@ Domain models for managing trustless cross-chain atomic swaps between agents.
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Optional
from enum import StrEnum
from uuid import uuid4
from sqlmodel import Field, SQLModel, Relationship
from sqlmodel import Field, SQLModel
class SwapStatus(StrEnum):
CREATED = "created" # Order created but not initiated on-chain
INITIATED = "initiated" # Hashlock created and funds locked on source chain
PARTICIPATING = "participating" # Hashlock matched and funds locked on target chain
COMPLETED = "completed" # Secret revealed and funds claimed
REFUNDED = "refunded" # Timelock expired, funds returned
FAILED = "failed" # General error state
class SwapStatus(str, Enum):
CREATED = "created" # Order created but not initiated on-chain
INITIATED = "initiated" # Hashlock created and funds locked on source chain
PARTICIPATING = "participating" # Hashlock matched and funds locked on target chain
COMPLETED = "completed" # Secret revealed and funds claimed
REFUNDED = "refunded" # Timelock expired, funds returned
FAILED = "failed" # General error state
class AtomicSwapOrder(SQLModel, table=True):
"""Represents a cross-chain atomic swap order between two parties"""
__tablename__ = "atomic_swap_order"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
# Initiator details (Party A)
initiator_agent_id: str = Field(index=True)
initiator_address: str = Field()
source_chain_id: int = Field(index=True)
source_token: str = Field() # "native" or ERC20 address
source_token: str = Field() # "native" or ERC20 address
source_amount: float = Field()
# Participant details (Party B)
participant_agent_id: str = Field(index=True)
participant_address: str = Field()
target_chain_id: int = Field(index=True)
target_token: str = Field() # "native" or ERC20 address
target_token: str = Field() # "native" or ERC20 address
target_amount: float = Field()
# Cryptographic elements
hashlock: str = Field(index=True) # sha256 hash of the secret
secret: Optional[str] = Field(default=None) # The secret (revealed upon completion)
hashlock: str = Field(index=True) # sha256 hash of the secret
secret: str | None = Field(default=None) # The secret (revealed upon completion)
# Timelocks (Unix timestamps)
source_timelock: int = Field() # Party A's timelock (longer)
target_timelock: int = Field() # Party B's timelock (shorter)
source_timelock: int = Field() # Party A's timelock (longer)
target_timelock: int = Field() # Party B's timelock (shorter)
# Transaction tracking
source_initiate_tx: Optional[str] = Field(default=None)
target_participate_tx: Optional[str] = Field(default=None)
target_complete_tx: Optional[str] = Field(default=None)
source_complete_tx: Optional[str] = Field(default=None)
refund_tx: Optional[str] = Field(default=None)
source_initiate_tx: str | None = Field(default=None)
target_participate_tx: str | None = Field(default=None)
target_complete_tx: str | None = Field(default=None)
source_complete_tx: str | None = Field(default=None)
refund_tx: str | None = Field(default=None)
status: SwapStatus = Field(default=SwapStatus.CREATED, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)

295
apps/coordinator-api/src/app/domain/bounty.py
View File

@@ -3,14 +3,15 @@ Bounty System Domain Models
Database models for AI agent bounty system with ZK-proof verification
"""
from typing import Optional, List, Dict, Any
from sqlmodel import Field, SQLModel, Column, JSON, Relationship
from datetime import datetime
from enum import Enum
import uuid
from datetime import datetime
from enum import StrEnum
from typing import Any
from sqlmodel import JSON, Column, Field, SQLModel
class BountyStatus(str, Enum):
class BountyStatus(StrEnum):
CREATED = "created"
ACTIVE = "active"
SUBMITTED = "submitted"
@@ -20,28 +21,28 @@ class BountyStatus(str, Enum):
DISPUTED = "disputed"
class BountyTier(str, Enum):
class BountyTier(StrEnum):
BRONZE = "bronze"
SILVER = "silver"
GOLD = "gold"
PLATINUM = "platinum"
class SubmissionStatus(str, Enum):
class SubmissionStatus(StrEnum):
PENDING = "pending"
VERIFIED = "verified"
REJECTED = "rejected"
DISPUTED = "disputed"
class StakeStatus(str, Enum):
class StakeStatus(StrEnum):
ACTIVE = "active"
UNBONDING = "unbonding"
COMPLETED = "completed"
SLASHED = "slashed"
class PerformanceTier(str, Enum):
class PerformanceTier(StrEnum):
BRONZE = "bronze"
SILVER = "silver"
GOLD = "gold"
@@ -51,6 +52,7 @@ class PerformanceTier(str, Enum):
class Bounty(SQLModel, table=True):
"""AI agent bounty with ZK-proof verification requirements"""
__tablename__ = "bounties"
bounty_id: str = Field(primary_key=True, default_factory=lambda: f"bounty_{uuid.uuid4().hex[:8]}")
@@ -60,380 +62,387 @@ class Bounty(SQLModel, table=True):
creator_id: str = Field(index=True)
tier: BountyTier = Field(default=BountyTier.BRONZE)
status: BountyStatus = Field(default=BountyStatus.CREATED)
# Performance requirements
performance_criteria: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
performance_criteria: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
min_accuracy: float = Field(default=90.0)
max_response_time: Optional[int] = Field(default=None) # milliseconds
max_response_time: int | None = Field(default=None) # milliseconds
# Timing
deadline: datetime = Field(index=True)
creation_time: datetime = Field(default_factory=datetime.utcnow)
# Limits
max_submissions: int = Field(default=100)
submission_count: int = Field(default=0)
# Configuration
requires_zk_proof: bool = Field(default=True)
auto_verify_threshold: float = Field(default=95.0)
# Winner information
winning_submission_id: Optional[str] = Field(default=None)
winner_address: Optional[str] = Field(default=None)
winning_submission_id: str | None = Field(default=None)
winner_address: str | None = Field(default=None)
# Fees
creation_fee: float = Field(default=0.0)
success_fee: float = Field(default=0.0)
platform_fee: float = Field(default=0.0)
# Metadata
tags: List[str] = Field(default_factory=list, sa_column=Column(JSON))
category: Optional[str] = Field(default=None)
difficulty: Optional[str] = Field(default=None)
tags: list[str] = Field(default_factory=list, sa_column=Column(JSON))
category: str | None = Field(default=None)
difficulty: str | None = Field(default=None)
# Relationships
# DISABLED: submissions: List["BountySubmission"] = Relationship(back_populates="bounty")
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_bounty_status_deadline", "columns": ["status", "deadline"]},
{"name": "ix_bounty_creator_status", "columns": ["creator_id", "status"]},
{"name": "ix_bounty_tier_reward", "columns": ["tier", "reward_amount"]},
]}
)
]
}
class BountySubmission(SQLModel, table=True):
"""Submission for a bounty with ZK-proof and performance metrics"""
__tablename__ = "bounty_submissions"
submission_id: str = Field(primary_key=True, default_factory=lambda: f"sub_{uuid.uuid4().hex[:8]}")
bounty_id: str = Field(foreign_key="bounties.bounty_id", index=True)
submitter_address: str = Field(index=True)
# Performance metrics
accuracy: float = Field(index=True)
response_time: Optional[int] = Field(default=None) # milliseconds
compute_power: Optional[float] = Field(default=None)
energy_efficiency: Optional[float] = Field(default=None)
response_time: int | None = Field(default=None) # milliseconds
compute_power: float | None = Field(default=None)
energy_efficiency: float | None = Field(default=None)
# ZK-proof data
zk_proof: Optional[Dict[str, Any]] = Field(default_factory=dict, sa_column=Column(JSON))
zk_proof: dict[str, Any] | None = Field(default_factory=dict, sa_column=Column(JSON))
performance_hash: str = Field(index=True)
# Status and verification
status: SubmissionStatus = Field(default=SubmissionStatus.PENDING)
verification_time: Optional[datetime] = Field(default=None)
verifier_address: Optional[str] = Field(default=None)
verification_time: datetime | None = Field(default=None)
verifier_address: str | None = Field(default=None)
# Dispute information
dispute_reason: Optional[str] = Field(default=None)
dispute_time: Optional[datetime] = Field(default=None)
dispute_reason: str | None = Field(default=None)
dispute_time: datetime | None = Field(default=None)
dispute_resolved: bool = Field(default=False)
# Timing
submission_time: datetime = Field(default_factory=datetime.utcnow)
# Metadata
submission_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
test_results: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
submission_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
test_results: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Relationships
# DISABLED: bounty: Bounty = Relationship(back_populates="submissions")
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_submission_bounty_status", "columns": ["bounty_id", "status"]},
{"name": "ix_submission_submitter_time", "columns": ["submitter_address", "submission_time"]},
{"name": "ix_submission_accuracy", "columns": ["accuracy"]},
]}
)
]
}
class AgentStake(SQLModel, table=True):
"""Staking position on an AI agent wallet"""
__tablename__ = "agent_stakes"
stake_id: str = Field(primary_key=True, default_factory=lambda: f"stake_{uuid.uuid4().hex[:8]}")
staker_address: str = Field(index=True)
agent_wallet: str = Field(index=True)
# Stake details
amount: float = Field(index=True)
lock_period: int = Field(default=30) # days
start_time: datetime = Field(default_factory=datetime.utcnow)
end_time: datetime
# Status and rewards
status: StakeStatus = Field(default=StakeStatus.ACTIVE)
accumulated_rewards: float = Field(default=0.0)
last_reward_time: datetime = Field(default_factory=datetime.utcnow)
# APY and performance
current_apy: float = Field(default=5.0) # percentage
agent_tier: PerformanceTier = Field(default=PerformanceTier.BRONZE)
performance_multiplier: float = Field(default=1.0)
# Configuration
auto_compound: bool = Field(default=False)
unbonding_time: Optional[datetime] = Field(default=None)
unbonding_time: datetime | None = Field(default=None)
# Penalties and bonuses
early_unbond_penalty: float = Field(default=0.0)
lock_bonus_multiplier: float = Field(default=1.0)
# Metadata
stake_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
stake_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_stake_agent_status", "columns": ["agent_wallet", "status"]},
{"name": "ix_stake_staker_status", "columns": ["staker_address", "status"]},
{"name": "ix_stake_amount_apy", "columns": ["amount", "current_apy"]},
]}
)
]
}
class AgentMetrics(SQLModel, table=True):
"""Performance metrics for AI agents"""
__tablename__ = "agent_metrics"
agent_wallet: str = Field(primary_key=True, index=True)
# Staking metrics
total_staked: float = Field(default=0.0)
staker_count: int = Field(default=0)
total_rewards_distributed: float = Field(default=0.0)
# Performance metrics
average_accuracy: float = Field(default=0.0)
total_submissions: int = Field(default=0)
successful_submissions: int = Field(default=0)
success_rate: float = Field(default=0.0)
# Tier and scoring
current_tier: PerformanceTier = Field(default=PerformanceTier.BRONZE)
tier_score: float = Field(default=60.0)
reputation_score: float = Field(default=0.0)
# Timing
last_update_time: datetime = Field(default_factory=datetime.utcnow)
first_submission_time: Optional[datetime] = Field(default=None)
first_submission_time: datetime | None = Field(default=None)
# Additional metrics
average_response_time: Optional[float] = Field(default=None)
total_compute_time: Optional[float] = Field(default=None)
energy_efficiency_score: Optional[float] = Field(default=None)
average_response_time: float | None = Field(default=None)
total_compute_time: float | None = Field(default=None)
energy_efficiency_score: float | None = Field(default=None)
# Historical data
weekly_accuracy: List[float] = Field(default_factory=list, sa_column=Column(JSON))
monthly_earnings: List[float] = Field(default_factory=list, sa_column=Column(JSON))
weekly_accuracy: list[float] = Field(default_factory=list, sa_column=Column(JSON))
monthly_earnings: list[float] = Field(default_factory=list, sa_column=Column(JSON))
# Metadata
agent_meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
agent_meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Relationships
# DISABLED: stakes: List[AgentStake] = Relationship(back_populates="agent_metrics")
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_metrics_tier_score", "columns": ["current_tier", "tier_score"]},
{"name": "ix_metrics_staked", "columns": ["total_staked"]},
{"name": "ix_metrics_accuracy", "columns": ["average_accuracy"]},
]}
)
]
}
class StakingPool(SQLModel, table=True):
"""Staking pool for an agent"""
__tablename__ = "staking_pools"
agent_wallet: str = Field(primary_key=True, index=True)
# Pool metrics
total_staked: float = Field(default=0.0)
total_rewards: float = Field(default=0.0)
pool_apy: float = Field(default=5.0)
# Staker information
staker_count: int = Field(default=0)
active_stakers: List[str] = Field(default_factory=list, sa_column=Column(JSON))
active_stakers: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Distribution
last_distribution_time: datetime = Field(default_factory=datetime.utcnow)
distribution_frequency: int = Field(default=1) # days
# Pool configuration
min_stake_amount: float = Field(default=100.0)
max_stake_amount: float = Field(default=100000.0)
auto_compound_enabled: bool = Field(default=False)
# Performance tracking
pool_performance_score: float = Field(default=0.0)
volatility_score: float = Field(default=0.0)
# Metadata
pool_meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
pool_meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_pool_apy_staked", "columns": ["pool_apy", "total_staked"]},
{"name": "ix_pool_performance", "columns": ["pool_performance_score"]},
]}
)
]
}
class BountyIntegration(SQLModel, table=True):
"""Integration between performance verification and bounty completion"""
__tablename__ = "bounty_integrations"
integration_id: str = Field(primary_key=True, default_factory=lambda: f"int_{uuid.uuid4().hex[:8]}")
# Mapping information
performance_hash: str = Field(index=True)
bounty_id: str = Field(foreign_key="bounties.bounty_id", index=True)
submission_id: str = Field(foreign_key="bounty_submissions.submission_id", index=True)
# Status and timing
status: BountyStatus = Field(default=BountyStatus.CREATED)
created_at: datetime = Field(default_factory=datetime.utcnow)
processed_at: Optional[datetime] = Field(default=None)
processed_at: datetime | None = Field(default=None)
# Processing information
processing_attempts: int = Field(default=0)
error_message: Optional[str] = Field(default=None)
gas_used: Optional[int] = Field(default=None)
error_message: str | None = Field(default=None)
gas_used: int | None = Field(default=None)
# Verification results
auto_verified: bool = Field(default=False)
verification_threshold_met: bool = Field(default=False)
performance_score: Optional[float] = Field(default=None)
performance_score: float | None = Field(default=None)
# Metadata
integration_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
integration_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_integration_hash_status", "columns": ["performance_hash", "status"]},
{"name": "ix_integration_bounty", "columns": ["bounty_id"]},
{"name": "ix_integration_created", "columns": ["created_at"]},
]}
)
]
}
class BountyStats(SQLModel, table=True):
"""Aggregated bounty statistics"""
__tablename__ = "bounty_stats"
stats_id: str = Field(primary_key=True, default_factory=lambda: f"stats_{uuid.uuid4().hex[:8]}")
# Time period
period_start: datetime = Field(index=True)
period_end: datetime = Field(index=True)
period_type: str = Field(default="daily") # daily, weekly, monthly
# Bounty counts
total_bounties: int = Field(default=0)
active_bounties: int = Field(default=0)
completed_bounties: int = Field(default=0)
expired_bounties: int = Field(default=0)
disputed_bounties: int = Field(default=0)
# Financial metrics
total_value_locked: float = Field(default=0.0)
total_rewards_paid: float = Field(default=0.0)
total_fees_collected: float = Field(default=0.0)
average_reward: float = Field(default=0.0)
# Performance metrics
success_rate: float = Field(default=0.0)
average_completion_time: Optional[float] = Field(default=None) # hours
average_accuracy: Optional[float] = Field(default=None)
average_completion_time: float | None = Field(default=None) # hours
average_accuracy: float | None = Field(default=None)
# Participant metrics
unique_creators: int = Field(default=0)
unique_submitters: int = Field(default=0)
total_submissions: int = Field(default=0)
# Tier distribution
tier_distribution: Dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
tier_distribution: dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
# Metadata
stats_meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
stats_meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_stats_period", "columns": ["period_start", "period_end", "period_type"]},
{"name": "ix_stats_created", "columns": ["period_start"]},
]}
)
]
}
class EcosystemMetrics(SQLModel, table=True):
"""Ecosystem-wide metrics for dashboard"""
__tablename__ = "ecosystem_metrics"
metrics_id: str = Field(primary_key=True, default_factory=lambda: f"eco_{uuid.uuid4().hex[:8]}")
# Time period
timestamp: datetime = Field(default_factory=datetime.utcnow, index=True)
period_type: str = Field(default="hourly") # hourly, daily, weekly
# Developer metrics
active_developers: int = Field(default=0)
new_developers: int = Field(default=0)
developer_earnings_total: float = Field(default=0.0)
developer_earnings_average: float = Field(default=0.0)
# Agent metrics
total_agents: int = Field(default=0)
active_agents: int = Field(default=0)
agent_utilization_rate: float = Field(default=0.0)
average_agent_performance: float = Field(default=0.0)
# Staking metrics
total_staked: float = Field(default=0.0)
total_stakers: int = Field(default=0)
average_apy: float = Field(default=0.0)
staking_rewards_total: float = Field(default=0.0)
# Bounty metrics
active_bounties: int = Field(default=0)
bounty_completion_rate: float = Field(default=0.0)
average_bounty_reward: float = Field(default=0.0)
bounty_volume_total: float = Field(default=0.0)
# Treasury metrics
treasury_balance: float = Field(default=0.0)
treasury_inflow: float = Field(default=0.0)
treasury_outflow: float = Field(default=0.0)
dao_revenue: float = Field(default=0.0)
# Token metrics
token_circulating_supply: float = Field(default=0.0)
token_staked_percentage: float = Field(default=0.0)
token_burn_rate: float = Field(default=0.0)
# Metadata
metrics_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
metrics_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Indexes
__table_args__ = (
{"indexes": [
__table_args__ = {
"indexes": [
{"name": "ix_ecosystem_timestamp", "columns": ["timestamp", "period_type"]},
{"name": "ix_ecosystem_developers", "columns": ["active_developers"]},
{"name": "ix_ecosystem_staked", "columns": ["total_staked"]},
]}
)
]
}
# Update relationships
# DISABLED: AgentStake.agent_metrics = Relationship(back_populates="stakes")
# DISABLED: AgentStake.agent_metrics = Relationship(back_populates="stakes")

368
apps/coordinator-api/src/app/domain/certification.py
View File

@@ -3,17 +3,17 @@ Agent Certification and Partnership Domain Models
Implements SQLModel definitions for certification, verification, and partnership programs
"""
from datetime import datetime, timedelta
from typing import Optional, Dict, List, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Float, Integer, Text
from sqlmodel import JSON, Column, Field, SQLModel
class CertificationLevel(str, Enum):
class CertificationLevel(StrEnum):
"""Certification level enumeration"""
BASIC = "basic"
INTERMEDIATE = "intermediate"
ADVANCED = "advanced"
@@ -21,8 +21,9 @@ class CertificationLevel(str, Enum):
PREMIUM = "premium"
class CertificationStatus(str, Enum):
class CertificationStatus(StrEnum):
"""Certification status enumeration"""
PENDING = "pending"
ACTIVE = "active"
EXPIRED = "expired"
@@ -30,8 +31,9 @@ class CertificationStatus(str, Enum):
SUSPENDED = "suspended"
class VerificationType(str, Enum):
class VerificationType(StrEnum):
"""Verification type enumeration"""
IDENTITY = "identity"
PERFORMANCE = "performance"
RELIABILITY = "reliability"
@@ -40,8 +42,9 @@ class VerificationType(str, Enum):
CAPABILITY = "capability"
class PartnershipType(str, Enum):
class PartnershipType(StrEnum):
"""Partnership type enumeration"""
TECHNOLOGY = "technology"
SERVICE = "service"
RESELLER = "reseller"
@@ -50,8 +53,9 @@ class PartnershipType(str, Enum):
AFFILIATE = "affiliate"
class BadgeType(str, Enum):
class BadgeType(StrEnum):
"""Badge type enumeration"""
ACHIEVEMENT = "achievement"
MILESTONE = "milestone"
RECOGNITION = "recognition"
@@ -62,392 +66,392 @@ class BadgeType(str, Enum):
class AgentCertification(SQLModel, table=True):
"""Agent certification records"""
__tablename__ = "agent_certifications"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"cert_{uuid4().hex[:8]}", primary_key=True)
certification_id: str = Field(unique=True, index=True)
# Certification details
agent_id: str = Field(index=True)
certification_level: CertificationLevel
certification_type: str = Field(default="standard") # standard, specialized, enterprise
# Issuance information
issued_by: str = Field(index=True) # Who issued the certification
issued_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
verification_hash: str = Field(max_length=64) # Blockchain verification hash
# Status and metadata
status: CertificationStatus = Field(default=CertificationStatus.ACTIVE)
renewal_count: int = Field(default=0)
last_renewed_at: Optional[datetime] = None
last_renewed_at: datetime | None = None
# Requirements and verification
requirements_met: List[str] = Field(default=[], sa_column=Column(JSON))
verification_results: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
supporting_documents: List[str] = Field(default=[], sa_column=Column(JSON))
requirements_met: list[str] = Field(default=[], sa_column=Column(JSON))
verification_results: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
supporting_documents: list[str] = Field(default=[], sa_column=Column(JSON))
# Benefits and privileges
granted_privileges: List[str] = Field(default=[], sa_column=Column(JSON))
access_levels: List[str] = Field(default=[], sa_column=Column(JSON))
special_capabilities: List[str] = Field(default=[], sa_column=Column(JSON))
granted_privileges: list[str] = Field(default=[], sa_column=Column(JSON))
access_levels: list[str] = Field(default=[], sa_column=Column(JSON))
special_capabilities: list[str] = Field(default=[], sa_column=Column(JSON))
# Audit trail
audit_log: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
last_verified_at: Optional[datetime] = None
audit_log: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
last_verified_at: datetime | None = None
# Additional data
cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
notes: str = Field(default="", max_length=1000)
class CertificationRequirement(SQLModel, table=True):
"""Certification requirements and criteria"""
__tablename__ = "certification_requirements"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"req_{uuid4().hex[:8]}", primary_key=True)
# Requirement details
certification_level: CertificationLevel
requirement_type: VerificationType
requirement_name: str = Field(max_length=100)
description: str = Field(default="", max_length=500)
# Criteria and thresholds
criteria: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
minimum_threshold: Optional[float] = None
maximum_threshold: Optional[float] = None
required_values: List[str] = Field(default=[], sa_column=Column(JSON))
criteria: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
minimum_threshold: float | None = None
maximum_threshold: float | None = None
required_values: list[str] = Field(default=[], sa_column=Column(JSON))
# Verification method
verification_method: str = Field(default="automated") # automated, manual, hybrid
verification_frequency: str = Field(default="once") # once, monthly, quarterly, annually
# Dependencies and prerequisites
prerequisites: List[str] = Field(default=[], sa_column=Column(JSON))
depends_on: List[str] = Field(default=[], sa_column=Column(JSON))
prerequisites: list[str] = Field(default=[], sa_column=Column(JSON))
depends_on: list[str] = Field(default=[], sa_column=Column(JSON))
# Status and configuration
is_active: bool = Field(default=True)
is_mandatory: bool = Field(default=True)
weight: float = Field(default=1.0) # Importance weight
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
effective_date: datetime = Field(default_factory=datetime.utcnow)
expiry_date: Optional[datetime] = None
expiry_date: datetime | None = None
# Additional data
cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class VerificationRecord(SQLModel, table=True):
"""Agent verification records and results"""
__tablename__ = "verification_records"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"verify_{uuid4().hex[:8]}", primary_key=True)
verification_id: str = Field(unique=True, index=True)
# Verification details
agent_id: str = Field(index=True)
verification_type: VerificationType
verification_method: str = Field(default="automated")
# Request information
requested_by: str = Field(index=True)
requested_at: datetime = Field(default_factory=datetime.utcnow)
priority: str = Field(default="normal") # low, normal, high, urgent
# Verification process
started_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
processing_time: Optional[float] = None # seconds
started_at: datetime | None = None
completed_at: datetime | None = None
processing_time: float | None = None # seconds
# Results and outcomes
status: str = Field(default="pending") # pending, in_progress, passed, failed, cancelled
result_score: Optional[float] = None
result_details: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
failure_reasons: List[str] = Field(default=[], sa_column=Column(JSON))
result_score: float | None = None
result_details: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
failure_reasons: list[str] = Field(default=[], sa_column=Column(JSON))
# Verification data
input_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
output_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
evidence: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
input_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
output_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
evidence: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Review and approval
reviewed_by: Optional[str] = None
reviewed_at: Optional[datetime] = None
approved_by: Optional[str] = None
approved_at: Optional[datetime] = None
reviewed_by: str | None = None
reviewed_at: datetime | None = None
approved_by: str | None = None
approved_at: datetime | None = None
# Audit and compliance
compliance_score: Optional[float] = None
risk_assessment: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
audit_trail: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
compliance_score: float | None = None
risk_assessment: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
audit_trail: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
# Additional data
cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
notes: str = Field(default="", max_length=1000)
class PartnershipProgram(SQLModel, table=True):
"""Partnership programs and alliances"""
__tablename__ = "partnership_programs"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"partner_{uuid4().hex[:8]}", primary_key=True)
program_id: str = Field(unique=True, index=True)
# Program details
program_name: str = Field(max_length=200)
program_type: PartnershipType
description: str = Field(default="", max_length=1000)
# Program configuration
tier_levels: List[str] = Field(default=[], sa_column=Column(JSON))
benefits_by_tier: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
requirements_by_tier: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
tier_levels: list[str] = Field(default=[], sa_column=Column(JSON))
benefits_by_tier: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
requirements_by_tier: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Eligibility criteria
eligibility_requirements: List[str] = Field(default=[], sa_column=Column(JSON))
minimum_criteria: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
exclusion_criteria: List[str] = Field(default=[], sa_column=Column(JSON))
eligibility_requirements: list[str] = Field(default=[], sa_column=Column(JSON))
minimum_criteria: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
exclusion_criteria: list[str] = Field(default=[], sa_column=Column(JSON))
# Program benefits
financial_benefits: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
non_financial_benefits: List[str] = Field(default=[], sa_column=Column(JSON))
exclusive_access: List[str] = Field(default=[], sa_column=Column(JSON))
financial_benefits: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
non_financial_benefits: list[str] = Field(default=[], sa_column=Column(JSON))
exclusive_access: list[str] = Field(default=[], sa_column=Column(JSON))
# Partnership terms
agreement_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
commission_structure: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
agreement_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
commission_structure: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
# Status and management
status: str = Field(default="active") # active, inactive, suspended, terminated
max_participants: Optional[int] = None
max_participants: int | None = None
current_participants: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
launched_at: Optional[datetime] = None
expires_at: Optional[datetime] = None
launched_at: datetime | None = None
expires_at: datetime | None = None
# Additional data
program_cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
contact_info: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
program_cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
contact_info: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class AgentPartnership(SQLModel, table=True):
"""Agent participation in partnership programs"""
__tablename__ = "agent_partnerships"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"agent_partner_{uuid4().hex[:8]}", primary_key=True)
partnership_id: str = Field(unique=True, index=True)
# Partnership details
agent_id: str = Field(index=True)
program_id: str = Field(index=True)
partnership_type: PartnershipType
current_tier: str = Field(default="basic")
# Application and approval
applied_at: datetime = Field(default_factory=datetime.utcnow)
approved_by: Optional[str] = None
approved_at: Optional[datetime] = None
rejection_reasons: List[str] = Field(default=[], sa_column=Column(JSON))
approved_by: str | None = None
approved_at: datetime | None = None
rejection_reasons: list[str] = Field(default=[], sa_column=Column(JSON))
# Performance and metrics
performance_score: float = Field(default=0.0)
performance_metrics: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
contribution_value: float = Field(default=0.0)
# Benefits and compensation
earned_benefits: List[str] = Field(default=[], sa_column=Column(JSON))
earned_benefits: list[str] = Field(default=[], sa_column=Column(JSON))
total_earnings: float = Field(default=0.0)
pending_payments: float = Field(default=0.0)
# Status and lifecycle
status: str = Field(default="active") # active, inactive, suspended, terminated
tier_progress: float = Field(default=0.0, ge=0, le=100.0)
next_tier_eligible: bool = Field(default=False)
# Agreement details
agreement_signed: bool = Field(default=False)
agreement_signed_at: Optional[datetime] = None
agreement_expires_at: Optional[datetime] = None
agreement_signed_at: datetime | None = None
agreement_expires_at: datetime | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_activity: Optional[datetime] = None
last_activity: datetime | None = None
# Additional data
partnership_cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
partnership_cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
notes: str = Field(default="", max_length=1000)
class AchievementBadge(SQLModel, table=True):
"""Achievement and recognition badges"""
__tablename__ = "achievement_badges"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"badge_{uuid4().hex[:8]}", primary_key=True)
badge_id: str = Field(unique=True, index=True)
# Badge details
badge_name: str = Field(max_length=100)
badge_type: BadgeType
description: str = Field(default="", max_length=500)
badge_icon: str = Field(default="", max_length=200) # Icon identifier or URL
# Badge criteria
achievement_criteria: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
required_metrics: List[str] = Field(default=[], sa_column=Column(JSON))
threshold_values: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
achievement_criteria: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
required_metrics: list[str] = Field(default=[], sa_column=Column(JSON))
threshold_values: dict[str, float] = Field(default={}, sa_column=Column(JSON))
# Badge properties
rarity: str = Field(default="common") # common, uncommon, rare, epic, legendary
point_value: int = Field(default=0)
category: str = Field(default="general") # performance, contribution, specialization, excellence
# Visual design
color_scheme: Dict[str, str] = Field(default={}, sa_column=Column(JSON))
display_properties: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
color_scheme: dict[str, str] = Field(default={}, sa_column=Column(JSON))
display_properties: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Status and availability
is_active: bool = Field(default=True)
is_limited: bool = Field(default=False)
max_awards: Optional[int] = None
max_awards: int | None = None
current_awards: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
available_from: datetime = Field(default_factory=datetime.utcnow)
available_until: Optional[datetime] = None
available_until: datetime | None = None
# Additional data
badge_cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
badge_cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
requirements_text: str = Field(default="", max_length=1000)
class AgentBadge(SQLModel, table=True):
"""Agent earned badges and achievements"""
__tablename__ = "agent_badges"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"agent_badge_{uuid4().hex[:8]}", primary_key=True)
# Badge relationship
agent_id: str = Field(index=True)
badge_id: str = Field(index=True)
# Award details
awarded_by: str = Field(index=True) # System or user who awarded the badge
awarded_at: datetime = Field(default_factory=datetime.utcnow)
award_reason: str = Field(default="", max_length=500)
# Achievement context
achievement_context: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
metrics_at_award: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
supporting_evidence: List[str] = Field(default=[], sa_column=Column(JSON))
achievement_context: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
metrics_at_award: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
supporting_evidence: list[str] = Field(default=[], sa_column=Column(JSON))
# Badge status
is_displayed: bool = Field(default=True)
is_featured: bool = Field(default=False)
display_order: int = Field(default=0)
# Progress tracking (for progressive badges)
current_progress: float = Field(default=0.0, ge=0, le=100.0)
next_milestone: Optional[str] = None
next_milestone: str | None = None
# Expiration and renewal
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
is_permanent: bool = Field(default=True)
renewal_criteria: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
renewal_criteria: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Social features
share_count: int = Field(default=0)
view_count: int = Field(default=0)
congratulation_count: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_viewed_at: Optional[datetime] = None
last_viewed_at: datetime | None = None
# Additional data
badge_cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
badge_cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
notes: str = Field(default="", max_length=1000)
class CertificationAudit(SQLModel, table=True):
"""Certification audit and compliance records"""
__tablename__ = "certification_audits"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"audit_{uuid4().hex[:8]}", primary_key=True)
audit_id: str = Field(unique=True, index=True)
# Audit details
audit_type: str = Field(max_length=50) # routine, investigation, compliance, security
audit_scope: str = Field(max_length=100) # individual, program, system
target_entity_id: str = Field(index=True) # agent_id, certification_id, etc.
# Audit scheduling
scheduled_by: str = Field(index=True)
scheduled_at: datetime = Field(default_factory=datetime.utcnow)
started_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
started_at: datetime | None = None
completed_at: datetime | None = None
# Audit execution
auditor_id: str = Field(index=True)
audit_methodology: str = Field(default="", max_length=500)
checklists: List[str] = Field(default=[], sa_column=Column(JSON))
checklists: list[str] = Field(default=[], sa_column=Column(JSON))
# Findings and results
overall_score: Optional[float] = None
compliance_score: Optional[float] = None
risk_score: Optional[float] = None
findings: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
violations: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
recommendations: List[str] = Field(default=[], sa_column=Column(JSON))
overall_score: float | None = None
compliance_score: float | None = None
risk_score: float | None = None
findings: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
violations: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
recommendations: list[str] = Field(default=[], sa_column=Column(JSON))
# Actions and resolutions
corrective_actions: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
corrective_actions: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
follow_up_required: bool = Field(default=False)
follow_up_date: Optional[datetime] = None
follow_up_date: datetime | None = None
# Status and outcome
status: str = Field(default="scheduled") # scheduled, in_progress, completed, failed, cancelled
outcome: str = Field(default="pending") # pass, fail, conditional, pending_review
# Reporting and documentation
report_generated: bool = Field(default=False)
report_url: Optional[str] = None
evidence_documents: List[str] = Field(default=[], sa_column=Column(JSON))
report_url: str | None = None
evidence_documents: list[str] = Field(default=[], sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional data
audit_cert_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
audit_cert_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
notes: str = Field(default="", max_length=2000)

107
apps/coordinator-api/src/app/domain/community.py
View File

@@ -3,149 +3,164 @@ Community and Developer Ecosystem Models
Database models for OpenClaw agent community, third-party solutions, and innovation labs
"""
from typing import Optional, List, Dict, Any
from sqlmodel import Field, SQLModel, Column, JSON, Relationship
from datetime import datetime
from enum import Enum
import uuid
from datetime import datetime
from enum import StrEnum
from typing import Any
class DeveloperTier(str, Enum):
from sqlmodel import JSON, Column, Field, SQLModel
class DeveloperTier(StrEnum):
NOVICE = "novice"
BUILDER = "builder"
EXPERT = "expert"
MASTER = "master"
PARTNER = "partner"
class SolutionStatus(str, Enum):
class SolutionStatus(StrEnum):
DRAFT = "draft"
REVIEW = "review"
PUBLISHED = "published"
DEPRECATED = "deprecated"
REJECTED = "rejected"
class LabStatus(str, Enum):
class LabStatus(StrEnum):
PROPOSED = "proposed"
FUNDING = "funding"
ACTIVE = "active"
COMPLETED = "completed"
ARCHIVED = "archived"
class HackathonStatus(str, Enum):
class HackathonStatus(StrEnum):
ANNOUNCED = "announced"
REGISTRATION = "registration"
ONGOING = "ongoing"
JUDGING = "judging"
COMPLETED = "completed"
class DeveloperProfile(SQLModel, table=True):
"""Profile for a developer in the OpenClaw community"""
__tablename__ = "developer_profiles"
developer_id: str = Field(primary_key=True, default_factory=lambda: f"dev_{uuid.uuid4().hex[:8]}")
user_id: str = Field(index=True)
username: str = Field(unique=True)
bio: Optional[str] = None
bio: str | None = None
tier: DeveloperTier = Field(default=DeveloperTier.NOVICE)
reputation_score: float = Field(default=0.0)
total_earnings: float = Field(default=0.0)
skills: List[str] = Field(default_factory=list, sa_column=Column(JSON))
github_handle: Optional[str] = None
website: Optional[str] = None
skills: list[str] = Field(default_factory=list, sa_column=Column(JSON))
github_handle: str | None = None
website: str | None = None
joined_at: datetime = Field(default_factory=datetime.utcnow)
last_active: datetime = Field(default_factory=datetime.utcnow)
class AgentSolution(SQLModel, table=True):
"""A third-party agent solution available in the developer marketplace"""
__tablename__ = "agent_solutions"
solution_id: str = Field(primary_key=True, default_factory=lambda: f"sol_{uuid.uuid4().hex[:8]}")
developer_id: str = Field(foreign_key="developer_profiles.developer_id")
title: str
description: str
version: str = Field(default="1.0.0")
capabilities: List[str] = Field(default_factory=list, sa_column=Column(JSON))
frameworks: List[str] = Field(default_factory=list, sa_column=Column(JSON))
price_model: str = Field(default="free") # free, one_time, subscription, usage_based
capabilities: list[str] = Field(default_factory=list, sa_column=Column(JSON))
frameworks: list[str] = Field(default_factory=list, sa_column=Column(JSON))
price_model: str = Field(default="free") # free, one_time, subscription, usage_based
price_amount: float = Field(default=0.0)
currency: str = Field(default="AITBC")
status: SolutionStatus = Field(default=SolutionStatus.DRAFT)
downloads: int = Field(default=0)
average_rating: float = Field(default=0.0)
review_count: int = Field(default=0)
solution_meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
solution_meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
published_at: Optional[datetime] = None
published_at: datetime | None = None
class InnovationLab(SQLModel, table=True):
"""Research program or innovation lab for agent development"""
__tablename__ = "innovation_labs"
lab_id: str = Field(primary_key=True, default_factory=lambda: f"lab_{uuid.uuid4().hex[:8]}")
title: str
description: str
research_area: str
lead_researcher_id: str = Field(foreign_key="developer_profiles.developer_id")
members: List[str] = Field(default_factory=list, sa_column=Column(JSON)) # List of developer_ids
members: list[str] = Field(default_factory=list, sa_column=Column(JSON)) # List of developer_ids
status: LabStatus = Field(default=LabStatus.PROPOSED)
funding_goal: float = Field(default=0.0)
current_funding: float = Field(default=0.0)
milestones: List[Dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
publications: List[Dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
milestones: list[dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
publications: list[dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
target_completion: Optional[datetime] = None
target_completion: datetime | None = None
class CommunityPost(SQLModel, table=True):
"""A post in the community support/collaboration platform"""
__tablename__ = "community_posts"
post_id: str = Field(primary_key=True, default_factory=lambda: f"post_{uuid.uuid4().hex[:8]}")
author_id: str = Field(foreign_key="developer_profiles.developer_id")
title: str
content: str
category: str = Field(default="discussion") # discussion, question, showcase, tutorial
tags: List[str] = Field(default_factory=list, sa_column=Column(JSON))
category: str = Field(default="discussion") # discussion, question, showcase, tutorial
tags: list[str] = Field(default_factory=list, sa_column=Column(JSON))
upvotes: int = Field(default=0)
views: int = Field(default=0)
is_resolved: bool = Field(default=False)
parent_post_id: Optional[str] = Field(default=None, foreign_key="community_posts.post_id")
parent_post_id: str | None = Field(default=None, foreign_key="community_posts.post_id")
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
class Hackathon(SQLModel, table=True):
"""Innovation challenge or hackathon"""
__tablename__ = "hackathons"
hackathon_id: str = Field(primary_key=True, default_factory=lambda: f"hack_{uuid.uuid4().hex[:8]}")
title: str
description: str
theme: str
sponsor: str = Field(default="AITBC Foundation")
prize_pool: float = Field(default=0.0)
prize_currency: str = Field(default="AITBC")
status: HackathonStatus = Field(default=HackathonStatus.ANNOUNCED)
participants: List[str] = Field(default_factory=list, sa_column=Column(JSON)) # List of developer_ids
submissions: List[Dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
participants: list[str] = Field(default_factory=list, sa_column=Column(JSON)) # List of developer_ids
submissions: list[dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
registration_start: datetime
registration_end: datetime
event_start: datetime

193
apps/coordinator-api/src/app/domain/cross_chain_bridge.py
View File

@@ -7,15 +7,13 @@ Domain models for cross-chain asset transfers, bridge requests, and validator ma
from __future__ import annotations
from datetime import datetime, timedelta
from enum import Enum
from typing import Dict, List, Optional
from uuid import uuid4
from enum import StrEnum
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class BridgeRequestStatus(str, Enum):
class BridgeRequestStatus(StrEnum):
PENDING = "pending"
CONFIRMED = "confirmed"
COMPLETED = "completed"
@@ -25,7 +23,7 @@ class BridgeRequestStatus(str, Enum):
RESOLVED = "resolved"
class ChainType(str, Enum):
class ChainType(StrEnum):
ETHEREUM = "ethereum"
POLYGON = "polygon"
BSC = "bsc"
@@ -36,7 +34,7 @@ class ChainType(str, Enum):
HARMONY = "harmony"
class TransactionType(str, Enum):
class TransactionType(StrEnum):
INITIATION = "initiation"
CONFIRMATION = "confirmation"
COMPLETION = "completion"
@@ -44,7 +42,7 @@ class TransactionType(str, Enum):
DISPUTE = "dispute"
class ValidatorStatus(str, Enum):
class ValidatorStatus(StrEnum):
ACTIVE = "active"
INACTIVE = "inactive"
SUSPENDED = "suspended"
@@ -53,9 +51,10 @@ class ValidatorStatus(str, Enum):
class BridgeRequest(SQLModel, table=True):
"""Cross-chain bridge transfer request"""
__tablename__ = "bridge_request"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
contract_request_id: str = Field(index=True) # Contract request ID
sender_address: str = Field(index=True)
recipient_address: str = Field(index=True)
@@ -68,21 +67,21 @@ class BridgeRequest(SQLModel, table=True):
total_amount: float = Field(default=0.0) # Amount including fee
exchange_rate: float = Field(default=1.0) # Exchange rate between tokens
status: BridgeRequestStatus = Field(default=BridgeRequestStatus.PENDING, index=True)
zk_proof: Optional[str] = Field(default=None) # Zero-knowledge proof
merkle_proof: Optional[str] = Field(default=None) # Merkle proof for completion
lock_tx_hash: Optional[str] = Field(default=None, index=True) # Lock transaction hash
unlock_tx_hash: Optional[str] = Field(default=None, index=True) # Unlock transaction hash
zk_proof: str | None = Field(default=None) # Zero-knowledge proof
merkle_proof: str | None = Field(default=None) # Merkle proof for completion
lock_tx_hash: str | None = Field(default=None, index=True) # Lock transaction hash
unlock_tx_hash: str | None = Field(default=None, index=True) # Unlock transaction hash
confirmations: int = Field(default=0) # Number of confirmations received
required_confirmations: int = Field(default=3) # Required confirmations
dispute_reason: Optional[str] = Field(default=None)
resolution_action: Optional[str] = Field(default=None)
dispute_reason: str | None = Field(default=None)
resolution_action: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
updated_at: datetime = Field(default_factory=datetime.utcnow)
confirmed_at: Optional[datetime] = Field(default=None)
completed_at: Optional[datetime] = Field(default=None)
resolved_at: Optional[datetime] = Field(default=None)
confirmed_at: datetime | None = Field(default=None)
completed_at: datetime | None = Field(default=None)
resolved_at: datetime | None = Field(default=None)
expires_at: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(hours=24))
# Relationships
# transactions: List["BridgeTransaction"] = Relationship(back_populates="bridge_request")
# disputes: List["BridgeDispute"] = Relationship(back_populates="bridge_request")
@@ -90,9 +89,10 @@ class BridgeRequest(SQLModel, table=True):
class SupportedToken(SQLModel, table=True):
"""Supported tokens for cross-chain bridging"""
__tablename__ = "supported_token"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
token_address: str = Field(index=True)
token_symbol: str = Field(index=True)
token_name: str = Field(default="")
@@ -104,18 +104,19 @@ class SupportedToken(SQLModel, table=True):
requires_whitelist: bool = Field(default=False)
is_active: bool = Field(default=True, index=True)
is_wrapped: bool = Field(default=False) # Whether it's a wrapped token
original_token: Optional[str] = Field(default=None) # Original token address for wrapped tokens
supported_chains: List[int] = Field(default_factory=list, sa_column=Column(JSON))
bridge_contracts: Dict[int, str] = Field(default_factory=dict, sa_column=Column(JSON)) # Chain ID -> Contract address
original_token: str | None = Field(default=None) # Original token address for wrapped tokens
supported_chains: list[int] = Field(default_factory=list, sa_column=Column(JSON))
bridge_contracts: dict[int, str] = Field(default_factory=dict, sa_column=Column(JSON)) # Chain ID -> Contract address
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
class ChainConfig(SQLModel, table=True):
"""Configuration for supported blockchain networks"""
__tablename__ = "chain_config"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
chain_id: int = Field(index=True)
chain_name: str = Field(index=True)
chain_type: ChainType = Field(index=True)
@@ -140,9 +141,10 @@ class ChainConfig(SQLModel, table=True):
class Validator(SQLModel, table=True):
"""Bridge validator for cross-chain confirmations"""
__tablename__ = "validator"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
validator_address: str = Field(index=True)
validator_name: str = Field(default="")
weight: int = Field(default=1) # Validator weight
@@ -154,43 +156,44 @@ class Validator(SQLModel, table=True):
earned_fees: float = Field(default=0.0) # Total fees earned
reputation_score: float = Field(default=100.0) # Reputation score (0-100)
uptime_percentage: float = Field(default=100.0) # Uptime percentage
last_validation: Optional[datetime] = Field(default=None)
last_seen: Optional[datetime] = Field(default=None)
last_validation: datetime | None = Field(default=None)
last_seen: datetime | None = Field(default=None)
status: ValidatorStatus = Field(default=ValidatorStatus.ACTIVE, index=True)
is_active: bool = Field(default=True, index=True)
supported_chains: List[int] = Field(default_factory=list, sa_column=Column(JSON))
val_meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
supported_chains: list[int] = Field(default_factory=list, sa_column=Column(JSON))
val_meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# transactions: List["BridgeTransaction"] = Relationship(back_populates="validator")
class BridgeTransaction(SQLModel, table=True):
"""Transactions related to bridge requests"""
__tablename__ = "bridge_transaction"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
bridge_request_id: int = Field(foreign_key="bridge_request.id", index=True)
validator_address: Optional[str] = Field(default=None, index=True)
validator_address: str | None = Field(default=None, index=True)
transaction_type: TransactionType = Field(index=True)
transaction_hash: Optional[str] = Field(default=None, index=True)
block_number: Optional[int] = Field(default=None)
block_hash: Optional[str] = Field(default=None)
gas_used: Optional[int] = Field(default=None)
gas_price: Optional[float] = Field(default=None)
transaction_cost: Optional[float] = Field(default=None)
signature: Optional[str] = Field(default=None) # Validator signature
merkle_proof: Optional[List[str]] = Field(default_factory=list, sa_column=Column(JSON))
transaction_hash: str | None = Field(default=None, index=True)
block_number: int | None = Field(default=None)
block_hash: str | None = Field(default=None)
gas_used: int | None = Field(default=None)
gas_price: float | None = Field(default=None)
transaction_cost: float | None = Field(default=None)
signature: str | None = Field(default=None) # Validator signature
merkle_proof: list[str] | None = Field(default_factory=list, sa_column=Column(JSON))
confirmations: int = Field(default=0) # Number of confirmations
is_successful: bool = Field(default=False)
error_message: Optional[str] = Field(default=None)
error_message: str | None = Field(default=None)
retry_count: int = Field(default=0)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
confirmed_at: Optional[datetime] = Field(default=None)
completed_at: Optional[datetime] = Field(default=None)
confirmed_at: datetime | None = Field(default=None)
completed_at: datetime | None = Field(default=None)
# Relationships
# bridge_request: BridgeRequest = Relationship(back_populates="transactions")
# validator: Optional[Validator] = Relationship(back_populates="transactions")
@@ -198,53 +201,56 @@ class BridgeTransaction(SQLModel, table=True):
class BridgeDispute(SQLModel, table=True):
"""Dispute records for failed bridge transfers"""
__tablename__ = "bridge_dispute"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
bridge_request_id: int = Field(foreign_key="bridge_request.id", index=True)
dispute_type: str = Field(index=True) # TIMEOUT, INSUFFICIENT_FUNDS, VALIDATOR_MISBEHAVIOR, etc.
dispute_reason: str = Field(default="")
dispute_status: str = Field(default="open") # open, investigating, resolved, rejected
reporter_address: str = Field(index=True)
evidence: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
resolution_action: Optional[str] = Field(default=None)
resolution_details: Optional[str] = Field(default=None)
refund_amount: Optional[float] = Field(default=None)
compensation_amount: Optional[float] = Field(default=None)
penalty_amount: Optional[float] = Field(default=None)
investigator_address: Optional[str] = Field(default=None)
investigation_notes: Optional[str] = Field(default=None)
evidence: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
resolution_action: str | None = Field(default=None)
resolution_details: str | None = Field(default=None)
refund_amount: float | None = Field(default=None)
compensation_amount: float | None = Field(default=None)
penalty_amount: float | None = Field(default=None)
investigator_address: str | None = Field(default=None)
investigation_notes: str | None = Field(default=None)
is_resolved: bool = Field(default=False, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
updated_at: datetime = Field(default_factory=datetime.utcnow)
resolved_at: Optional[datetime] = Field(default=None)
resolved_at: datetime | None = Field(default=None)
# Relationships
# bridge_request: BridgeRequest = Relationship(back_populates="disputes")
class MerkleProof(SQLModel, table=True):
"""Merkle proofs for bridge transaction verification"""
__tablename__ = "merkle_proof"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
bridge_request_id: int = Field(foreign_key="bridge_request.id", index=True)
proof_hash: str = Field(index=True) # Merkle proof hash
merkle_root: str = Field(index=True) # Merkle root
proof_data: List[str] = Field(default_factory=list, sa_column=Column(JSON)) # Proof data
proof_data: list[str] = Field(default_factory=list, sa_column=Column(JSON)) # Proof data
leaf_index: int = Field(default=0) # Leaf index in tree
tree_depth: int = Field(default=0) # Tree depth
is_valid: bool = Field(default=False)
verified_at: Optional[datetime] = Field(default=None)
verified_at: datetime | None = Field(default=None)
expires_at: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(hours=24))
created_at: datetime = Field(default_factory=datetime.utcnow)
class BridgeStatistics(SQLModel, table=True):
"""Statistics for bridge operations"""
__tablename__ = "bridge_statistics"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
chain_id: int = Field(index=True)
token_address: str = Field(index=True)
date: datetime = Field(index=True)
@@ -263,35 +269,37 @@ class BridgeStatistics(SQLModel, table=True):
class BridgeAlert(SQLModel, table=True):
"""Alerts for bridge operations and issues"""
__tablename__ = "bridge_alert"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
alert_type: str = Field(index=True) # HIGH_FAILURE_RATE, LOW_LIQUIDITY, VALIDATOR_OFFLINE, etc.
severity: str = Field(index=True) # LOW, MEDIUM, HIGH, CRITICAL
chain_id: Optional[int] = Field(default=None, index=True)
token_address: Optional[str] = Field(default=None, index=True)
validator_address: Optional[str] = Field(default=None, index=True)
bridge_request_id: Optional[int] = Field(default=None, index=True)
chain_id: int | None = Field(default=None, index=True)
token_address: str | None = Field(default=None, index=True)
validator_address: str | None = Field(default=None, index=True)
bridge_request_id: int | None = Field(default=None, index=True)
title: str = Field(default="")
message: str = Field(default="")
val_meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
val_meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
threshold_value: float = Field(default=0.0) # Threshold that triggered alert
current_value: float = Field(default=0.0) # Current value
is_acknowledged: bool = Field(default=False, index=True)
acknowledged_by: Optional[str] = Field(default=None)
acknowledged_at: Optional[datetime] = Field(default=None)
acknowledged_by: str | None = Field(default=None)
acknowledged_at: datetime | None = Field(default=None)
is_resolved: bool = Field(default=False, index=True)
resolved_at: Optional[datetime] = Field(default=None)
resolution_notes: Optional[str] = Field(default=None)
resolved_at: datetime | None = Field(default=None)
resolution_notes: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
expires_at: datetime = Field(default_factory=lambda: datetime.utcnow() + timedelta(hours=24))
class BridgeConfiguration(SQLModel, table=True):
"""Configuration settings for bridge operations"""
__tablename__ = "bridge_configuration"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
config_key: str = Field(index=True)
config_value: str = Field(default="")
config_type: str = Field(default="string") # string, number, boolean, json
@@ -303,9 +311,10 @@ class BridgeConfiguration(SQLModel, table=True):
class LiquidityPool(SQLModel, table=True):
"""Liquidity pools for bridge operations"""
__tablename__ = "bridge_liquidity_pool"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
chain_id: int = Field(index=True)
token_address: str = Field(index=True)
pool_address: str = Field(index=True)
@@ -321,9 +330,10 @@ class LiquidityPool(SQLModel, table=True):
class BridgeSnapshot(SQLModel, table=True):
"""Daily snapshot of bridge operations"""
__tablename__ = "bridge_snapshot"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
snapshot_date: datetime = Field(index=True)
total_volume_24h: float = Field(default=0.0)
total_transactions_24h: int = Field(default=0)
@@ -335,16 +345,17 @@ class BridgeSnapshot(SQLModel, table=True):
active_validators: int = Field(default=0)
total_liquidity: float = Field(default=0.0)
bridge_utilization: float = Field(default=0.0)
top_tokens: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
top_chains: Dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
top_tokens: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
top_chains: dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
class ValidatorReward(SQLModel, table=True):
"""Rewards earned by validators"""
__tablename__ = "validator_reward"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
validator_address: str = Field(index=True)
bridge_request_id: int = Field(foreign_key="bridge_request.id", index=True)
reward_amount: float = Field(default=0.0)
@@ -352,6 +363,6 @@ class ValidatorReward(SQLModel, table=True):
reward_type: str = Field(index=True) # VALIDATION_FEE, PERFORMANCE_BONUS, etc.
reward_period: str = Field(index=True) # Daily, weekly, monthly
is_claimed: bool = Field(default=False, index=True)
claimed_at: Optional[datetime] = Field(default=None)
claim_transaction_hash: Optional[str] = Field(default=None)
claimed_at: datetime | None = Field(default=None)
claim_transaction_hash: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)

159
apps/coordinator-api/src/app/domain/cross_chain_reputation.py
View File

@@ -3,44 +3,40 @@ Cross-Chain Reputation Extensions
Extends the existing reputation system with cross-chain capabilities
"""
from datetime import datetime, date
from typing import Optional, Dict, List, Any
from datetime import date, datetime
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON, Index
from sqlalchemy import DateTime, func
from .reputation import AgentReputation, ReputationEvent, ReputationLevel
from sqlmodel import JSON, Column, Field, Index, SQLModel
class CrossChainReputationConfig(SQLModel, table=True):
"""Chain-specific reputation configuration for cross-chain aggregation"""
__tablename__ = "cross_chain_reputation_configs"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"config_{uuid4().hex[:8]}", primary_key=True)
chain_id: int = Field(index=True, unique=True)
# Weighting configuration
chain_weight: float = Field(default=1.0) # Weight in cross-chain aggregation
base_reputation_bonus: float = Field(default=0.0) # Base reputation for new agents
# Scoring configuration
transaction_success_weight: float = Field(default=0.1)
transaction_failure_weight: float = Field(default=-0.2)
dispute_penalty_weight: float = Field(default=-0.3)
# Thresholds
minimum_transactions_for_score: int = Field(default=5)
reputation_decay_rate: float = Field(default=0.01) # Daily decay rate
anomaly_detection_threshold: float = Field(default=0.3) # Score change threshold
# Configuration metadata
is_active: bool = Field(default=True)
configuration_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
configuration_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -48,114 +44,114 @@ class CrossChainReputationConfig(SQLModel, table=True):
class CrossChainReputationAggregation(SQLModel, table=True):
"""Aggregated cross-chain reputation data"""
__tablename__ = "cross_chain_reputation_aggregations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"agg_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True)
# Aggregated scores
aggregated_score: float = Field(index=True, ge=0.0, le=1.0)
weighted_score: float = Field(default=0.0, ge=0.0, le=1.0)
normalized_score: float = Field(default=0.0, ge=0.0, le=1.0)
# Chain breakdown
chain_count: int = Field(default=0)
active_chains: List[int] = Field(default_factory=list, sa_column=Column(JSON))
chain_scores: Dict[int, float] = Field(default_factory=dict, sa_column=Column(JSON))
chain_weights: Dict[int, float] = Field(default_factory=dict, sa_column=Column(JSON))
active_chains: list[int] = Field(default_factory=list, sa_column=Column(JSON))
chain_scores: dict[int, float] = Field(default_factory=dict, sa_column=Column(JSON))
chain_weights: dict[int, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Consistency metrics
score_variance: float = Field(default=0.0)
score_range: float = Field(default=0.0)
consistency_score: float = Field(default=1.0, ge=0.0, le=1.0)
# Verification status
verification_status: str = Field(default="pending") # pending, verified, failed
verification_details: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
verification_details: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Timestamps
last_updated: datetime = Field(default_factory=datetime.utcnow)
created_at: datetime = Field(default_factory=datetime.utcnow)
# Indexes
__table_args__ = (
Index('idx_cross_chain_agg_agent', 'agent_id'),
Index('idx_cross_chain_agg_score', 'aggregated_score'),
Index('idx_cross_chain_agg_updated', 'last_updated'),
Index('idx_cross_chain_agg_status', 'verification_status'),
Index("idx_cross_chain_agg_agent", "agent_id"),
Index("idx_cross_chain_agg_score", "aggregated_score"),
Index("idx_cross_chain_agg_updated", "last_updated"),
Index("idx_cross_chain_agg_status", "verification_status"),
)
class CrossChainReputationEvent(SQLModel, table=True):
"""Cross-chain reputation events and synchronizations"""
__tablename__ = "cross_chain_reputation_events"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"event_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True)
source_chain_id: int = Field(index=True)
target_chain_id: Optional[int] = Field(index=True)
target_chain_id: int | None = Field(index=True)
# Event details
event_type: str = Field(max_length=50) # aggregation, migration, verification, etc.
impact_score: float = Field(ge=-1.0, le=1.0)
description: str = Field(default="")
# Cross-chain data
source_reputation: Optional[float] = Field(default=None)
target_reputation: Optional[float] = Field(default=None)
reputation_change: Optional[float] = Field(default=None)
source_reputation: float | None = Field(default=None)
target_reputation: float | None = Field(default=None)
reputation_change: float | None = Field(default=None)
# Event metadata
event_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
event_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
source: str = Field(default="system") # system, user, oracle, etc.
verified: bool = Field(default=False)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
processed_at: Optional[datetime] = None
processed_at: datetime | None = None
# Indexes
__table_args__ = (
Index('idx_cross_chain_event_agent', 'agent_id'),
Index('idx_cross_chain_event_chains', 'source_chain_id', 'target_chain_id'),
Index('idx_cross_chain_event_type', 'event_type'),
Index('idx_cross_chain_event_created', 'created_at'),
Index("idx_cross_chain_event_agent", "agent_id"),
Index("idx_cross_chain_event_chains", "source_chain_id", "target_chain_id"),
Index("idx_cross_chain_event_type", "event_type"),
Index("idx_cross_chain_event_created", "created_at"),
)
class ReputationMetrics(SQLModel, table=True):
"""Aggregated reputation metrics for analytics"""
__tablename__ = "reputation_metrics"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"metrics_{uuid4().hex[:8]}", primary_key=True)
chain_id: int = Field(index=True)
metric_date: date = Field(index=True)
# Aggregated metrics
total_agents: int = Field(default=0)
average_reputation: float = Field(default=0.0)
reputation_distribution: Dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
reputation_distribution: dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
# Performance metrics
total_transactions: int = Field(default=0)
success_rate: float = Field(default=0.0)
dispute_rate: float = Field(default=0.0)
# Distribution metrics
level_distribution: Dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
score_distribution: Dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
level_distribution: dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
score_distribution: dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
# Cross-chain metrics
cross_chain_agents: int = Field(default=0)
average_consistency_score: float = Field(default=0.0)
chain_diversity_score: float = Field(default=0.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -164,8 +160,9 @@ class ReputationMetrics(SQLModel, table=True):
# Request/Response Models for Cross-Chain API
class CrossChainReputationRequest(SQLModel):
"""Request model for cross-chain reputation operations"""
agent_id: str
chain_ids: Optional[List[int]] = None
chain_ids: list[int] | None = None
include_history: bool = False
include_metrics: bool = False
aggregation_method: str = "weighted" # weighted, average, normalized
@@ -173,24 +170,27 @@ class CrossChainReputationRequest(SQLModel):
class CrossChainReputationUpdateRequest(SQLModel):
"""Request model for cross-chain reputation updates"""
agent_id: str
chain_id: int
reputation_score: float = Field(ge=0.0, le=1.0)
transaction_data: Dict[str, Any] = Field(default_factory=dict)
transaction_data: dict[str, Any] = Field(default_factory=dict)
source: str = "system"
description: str = ""
class CrossChainAggregationRequest(SQLModel):
"""Request model for cross-chain aggregation"""
agent_ids: List[str]
chain_ids: Optional[List[int]] = None
agent_ids: list[str]
chain_ids: list[int] | None = None
aggregation_method: str = "weighted"
force_recalculate: bool = False
class CrossChainVerificationRequest(SQLModel):
"""Request model for cross-chain reputation verification"""
agent_id: str
threshold: float = Field(default=0.5)
verification_method: str = "consistency" # consistency, weighted, minimum
@@ -200,37 +200,40 @@ class CrossChainVerificationRequest(SQLModel):
# Response Models
class CrossChainReputationResponse(SQLModel):
"""Response model for cross-chain reputation"""
agent_id: str
chain_reputations: Dict[int, Dict[str, Any]]
chain_reputations: dict[int, dict[str, Any]]
aggregated_score: float
weighted_score: float
normalized_score: float
chain_count: int
active_chains: List[int]
active_chains: list[int]
consistency_score: float
verification_status: str
last_updated: datetime
meta_data: Dict[str, Any] = Field(default_factory=dict)
meta_data: dict[str, Any] = Field(default_factory=dict)
class CrossChainAnalyticsResponse(SQLModel):
"""Response model for cross-chain analytics"""
chain_id: Optional[int]
chain_id: int | None
total_agents: int
cross_chain_agents: int
average_reputation: float
average_consistency_score: float
chain_diversity_score: float
reputation_distribution: Dict[str, int]
level_distribution: Dict[str, int]
score_distribution: Dict[str, int]
performance_metrics: Dict[str, Any]
cross_chain_metrics: Dict[str, Any]
reputation_distribution: dict[str, int]
level_distribution: dict[str, int]
score_distribution: dict[str, int]
performance_metrics: dict[str, Any]
cross_chain_metrics: dict[str, Any]
generated_at: datetime
class ReputationAnomalyResponse(SQLModel):
"""Response model for reputation anomalies"""
agent_id: str
chain_id: int
anomaly_type: str
@@ -241,16 +244,17 @@ class ReputationAnomalyResponse(SQLModel):
current_score: float
score_change: float
confidence: float
meta_data: Dict[str, Any] = Field(default_factory=dict)
meta_data: dict[str, Any] = Field(default_factory=dict)
class CrossChainLeaderboardResponse(SQLModel):
"""Response model for cross-chain reputation leaderboard"""
agents: List[CrossChainReputationResponse]
agents: list[CrossChainReputationResponse]
total_count: int
page: int
page_size: int
chain_filter: Optional[int]
chain_filter: int | None
sort_by: str
sort_order: str
last_updated: datetime
@@ -258,11 +262,12 @@ class CrossChainLeaderboardResponse(SQLModel):
class ReputationVerificationResponse(SQLModel):
"""Response model for reputation verification"""
agent_id: str
threshold: float
is_verified: bool
verification_score: float
chain_verifications: Dict[int, bool]
verification_details: Dict[str, Any]
consistency_analysis: Dict[str, Any]
chain_verifications: dict[int, bool]
verification_details: dict[str, Any]
consistency_analysis: dict[str, Any]
verified_at: datetime

75
apps/coordinator-api/src/app/domain/dao_governance.py
View File

@@ -7,14 +7,14 @@ Domain models for managing multi-jurisdictional DAOs, regional councils, and glo
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Dict, List, Optional
from enum import StrEnum
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class ProposalState(str, Enum):
class ProposalState(StrEnum):
PENDING = "pending"
ACTIVE = "active"
CANCELED = "canceled"
@@ -24,91 +24,100 @@ class ProposalState(str, Enum):
EXPIRED = "expired"
EXECUTED = "executed"
class ProposalType(str, Enum):
class ProposalType(StrEnum):
GRANT = "grant"
PARAMETER_CHANGE = "parameter_change"
MEMBER_ELECTION = "member_election"
GENERAL = "general"
class DAOMember(SQLModel, table=True):
"""A member participating in DAO governance"""
__tablename__ = "dao_member"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
wallet_address: str = Field(index=True, unique=True)
staked_amount: float = Field(default=0.0)
voting_power: float = Field(default=0.0)
is_council_member: bool = Field(default=False)
council_region: Optional[str] = Field(default=None, index=True)
council_region: str | None = Field(default=None, index=True)
joined_at: datetime = Field(default_factory=datetime.utcnow)
last_active: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: votes: List["Vote"] = Relationship(back_populates="member")
class DAOProposal(SQLModel, table=True):
"""A governance proposal"""
__tablename__ = "dao_proposal"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
contract_proposal_id: Optional[str] = Field(default=None, index=True)
contract_proposal_id: str | None = Field(default=None, index=True)
proposer_address: str = Field(index=True)
title: str = Field()
description: str = Field()
proposal_type: ProposalType = Field(default=ProposalType.GENERAL)
target_region: Optional[str] = Field(default=None, index=True) # None = Global
target_region: str | None = Field(default=None, index=True) # None = Global
status: ProposalState = Field(default=ProposalState.PENDING, index=True)
for_votes: float = Field(default=0.0)
against_votes: float = Field(default=0.0)
abstain_votes: float = Field(default=0.0)
execution_payload: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
execution_payload: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
start_time: datetime = Field(default_factory=datetime.utcnow)
end_time: datetime = Field(default_factory=datetime.utcnow)
created_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: votes: List["Vote"] = Relationship(back_populates="proposal")
class Vote(SQLModel, table=True):
"""A vote cast on a proposal"""
__tablename__ = "dao_vote"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
proposal_id: str = Field(foreign_key="dao_proposal.id", index=True)
member_id: str = Field(foreign_key="dao_member.id", index=True)
support: bool = Field() # True = For, False = Against
support: bool = Field() # True = For, False = Against
weight: float = Field()
tx_hash: Optional[str] = Field(default=None)
tx_hash: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: proposal: DAOProposal = Relationship(back_populates="votes")
# DISABLED: member: DAOMember = Relationship(back_populates="votes")
class TreasuryAllocation(SQLModel, table=True):
"""Tracks allocations and spending from the global treasury"""
__tablename__ = "treasury_allocation"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
proposal_id: Optional[str] = Field(foreign_key="dao_proposal.id", default=None)
proposal_id: str | None = Field(foreign_key="dao_proposal.id", default=None)
amount: float = Field()
token_symbol: str = Field(default="AITBC")
recipient_address: str = Field()
purpose: str = Field()
tx_hash: Optional[str] = Field(default=None)
tx_hash: str | None = Field(default=None)
executed_at: datetime = Field(default_factory=datetime.utcnow)

53
apps/coordinator-api/src/app/domain/decentralized_memory.py
View File

@@ -7,50 +7,53 @@ Domain models for managing agent memory and knowledge graphs on IPFS/Filecoin.
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Dict, Optional, List
from enum import StrEnum
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class MemoryType(str, Enum):
class MemoryType(StrEnum):
VECTOR_DB = "vector_db"
KNOWLEDGE_GRAPH = "knowledge_graph"
POLICY_WEIGHTS = "policy_weights"
EPISODIC = "episodic"
class StorageStatus(str, Enum):
PENDING = "pending" # Upload to IPFS pending
UPLOADED = "uploaded" # Available on IPFS
PINNED = "pinned" # Pinned on Filecoin/Pinata
ANCHORED = "anchored" # CID written to blockchain
FAILED = "failed" # Upload failed
class StorageStatus(StrEnum):
PENDING = "pending" # Upload to IPFS pending
UPLOADED = "uploaded" # Available on IPFS
PINNED = "pinned" # Pinned on Filecoin/Pinata
ANCHORED = "anchored" # CID written to blockchain
FAILED = "failed" # Upload failed
class AgentMemoryNode(SQLModel, table=True):
"""Represents a chunk of memory or knowledge stored on decentralized storage"""
__tablename__ = "agent_memory_node"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
agent_id: str = Field(index=True)
memory_type: MemoryType = Field(index=True)
# Decentralized Storage Identifiers
cid: Optional[str] = Field(default=None, index=True) # IPFS Content Identifier
size_bytes: Optional[int] = Field(default=None)
cid: str | None = Field(default=None, index=True) # IPFS Content Identifier
size_bytes: int | None = Field(default=None)
# Encryption and Security
is_encrypted: bool = Field(default=True)
encryption_key_id: Optional[str] = Field(default=None) # Reference to KMS or Lit Protocol
zk_proof_hash: Optional[str] = Field(default=None) # Hash of the ZK proof verifying content validity
encryption_key_id: str | None = Field(default=None) # Reference to KMS or Lit Protocol
zk_proof_hash: str | None = Field(default=None) # Hash of the ZK proof verifying content validity
status: StorageStatus = Field(default=StorageStatus.PENDING, index=True)
meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
tags: List[str] = Field(default_factory=list, sa_column=Column(JSON))
meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
tags: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Blockchain Anchoring
anchor_tx_hash: Optional[str] = Field(default=None)
anchor_tx_hash: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)

103
apps/coordinator-api/src/app/domain/developer_platform.py
View File

@@ -7,40 +7,43 @@ Domain models for managing the developer ecosystem, bounties, certifications, an
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Dict, List, Optional
from enum import StrEnum
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class BountyStatus(str, Enum):
class BountyStatus(StrEnum):
OPEN = "open"
IN_PROGRESS = "in_progress"
IN_REVIEW = "in_review"
COMPLETED = "completed"
CANCELLED = "cancelled"
class CertificationLevel(str, Enum):
class CertificationLevel(StrEnum):
BEGINNER = "beginner"
INTERMEDIATE = "intermediate"
ADVANCED = "advanced"
EXPERT = "expert"
class DeveloperProfile(SQLModel, table=True):
"""Profile for a developer in the AITBC ecosystem"""
__tablename__ = "developer_profile"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
wallet_address: str = Field(index=True, unique=True)
github_handle: Optional[str] = Field(default=None)
email: Optional[str] = Field(default=None)
github_handle: str | None = Field(default=None)
email: str | None = Field(default=None)
reputation_score: float = Field(default=0.0)
total_earned_aitbc: float = Field(default=0.0)
skills: List[str] = Field(default_factory=list, sa_column=Column(JSON))
skills: list[str] = Field(default_factory=list, sa_column=Column(JSON))
is_active: bool = Field(default=True)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -49,87 +52,95 @@ class DeveloperProfile(SQLModel, table=True):
# DISABLED: certifications: List["DeveloperCertification"] = Relationship(back_populates="developer")
# DISABLED: bounty_submissions: List["BountySubmission"] = Relationship(back_populates="developer")
class DeveloperCertification(SQLModel, table=True):
"""Certifications earned by developers"""
__tablename__ = "developer_certification"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
developer_id: str = Field(foreign_key="developer_profile.id", index=True)
certification_name: str = Field(index=True)
level: CertificationLevel = Field(default=CertificationLevel.BEGINNER)
issued_by: str = Field() # Could be an agent or a DAO entity
issued_by: str = Field() # Could be an agent or a DAO entity
issued_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = Field(default=None)
ipfs_credential_cid: Optional[str] = Field(default=None) # Proof of certification
expires_at: datetime | None = Field(default=None)
ipfs_credential_cid: str | None = Field(default=None) # Proof of certification
# Relationships
# DISABLED: developer: DeveloperProfile = Relationship(back_populates="certifications")
class RegionalHub(SQLModel, table=True):
"""Regional developer hubs for local coordination"""
__tablename__ = "regional_hub"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
region_code: str = Field(index=True, unique=True) # e.g. "US-EAST", "EU-CENTRAL"
region_code: str = Field(index=True, unique=True) # e.g. "US-EAST", "EU-CENTRAL"
name: str = Field()
description: Optional[str] = Field(default=None)
lead_wallet_address: str = Field() # Hub lead
description: str | None = Field(default=None)
lead_wallet_address: str = Field() # Hub lead
member_count: int = Field(default=0)
budget_allocation: float = Field(default=0.0)
spent_budget: float = Field(default=0.0)
created_at: datetime = Field(default_factory=datetime.utcnow)
class BountyTask(SQLModel, table=True):
"""Automated bounty board tasks"""
__tablename__ = "bounty_task"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
title: str = Field()
description: str = Field()
required_skills: List[str] = Field(default_factory=list, sa_column=Column(JSON))
required_skills: list[str] = Field(default_factory=list, sa_column=Column(JSON))
difficulty_level: CertificationLevel = Field(default=CertificationLevel.INTERMEDIATE)
reward_amount: float = Field()
reward_token: str = Field(default="AITBC")
status: BountyStatus = Field(default=BountyStatus.OPEN, index=True)
creator_address: str = Field(index=True)
assigned_developer_id: Optional[str] = Field(foreign_key="developer_profile.id", default=None)
deadline: Optional[datetime] = Field(default=None)
assigned_developer_id: str | None = Field(foreign_key="developer_profile.id", default=None)
deadline: datetime | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: submissions: List["BountySubmission"] = Relationship(back_populates="bounty")
class BountySubmission(SQLModel, table=True):
"""Submissions for bounty tasks"""
__tablename__ = "bounty_submission"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
bounty_id: str = Field(foreign_key="bounty_task.id", index=True)
developer_id: str = Field(foreign_key="developer_profile.id", index=True)
github_pr_url: Optional[str] = Field(default=None)
github_pr_url: str | None = Field(default=None)
submission_notes: str = Field(default="")
is_approved: bool = Field(default=False)
review_notes: Optional[str] = Field(default=None)
reviewer_address: Optional[str] = Field(default=None)
tx_hash_reward: Optional[str] = Field(default=None) # Hash of the reward payout transaction
review_notes: str | None = Field(default=None)
reviewer_address: str | None = Field(default=None)
tx_hash_reward: str | None = Field(default=None) # Hash of the reward payout transaction
submitted_at: datetime = Field(default_factory=datetime.utcnow)
reviewed_at: Optional[datetime] = Field(default=None)
reviewed_at: datetime | None = Field(default=None)
# Relationships
# DISABLED: bounty: BountyTask = Relationship(back_populates="submissions")

91
apps/coordinator-api/src/app/domain/federated_learning.py
View File

@@ -7,14 +7,14 @@ Domain models for managing cross-agent knowledge sharing and collaborative model
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Dict, List, Optional
from enum import StrEnum
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class TrainingStatus(str, Enum):
class TrainingStatus(StrEnum):
INITIALIZED = "initiated"
GATHERING_PARTICIPANTS = "gathering_participants"
TRAINING = "training"
@@ -22,36 +22,39 @@ class TrainingStatus(str, Enum):
COMPLETED = "completed"
FAILED = "failed"
class ParticipantStatus(str, Enum):
class ParticipantStatus(StrEnum):
INVITED = "invited"
JOINED = "joined"
TRAINING = "training"
SUBMITTED = "submitted"
DROPPED = "dropped"
class FederatedLearningSession(SQLModel, table=True):
"""Represents a collaborative training session across multiple agents"""
__tablename__ = "federated_learning_session"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
initiator_agent_id: str = Field(index=True)
task_description: str = Field()
model_architecture_cid: str = Field() # IPFS CID pointing to model structure definition
initial_weights_cid: Optional[str] = Field(default=None) # Optional starting point
model_architecture_cid: str = Field() # IPFS CID pointing to model structure definition
initial_weights_cid: str | None = Field(default=None) # Optional starting point
target_participants: int = Field(default=3)
current_round: int = Field(default=0)
total_rounds: int = Field(default=10)
aggregation_strategy: str = Field(default="fedavg") # e.g. fedavg, fedprox
aggregation_strategy: str = Field(default="fedavg") # e.g. fedavg, fedprox
min_participants_per_round: int = Field(default=2)
reward_pool_amount: float = Field(default=0.0) # Total AITBC allocated to reward participants
reward_pool_amount: float = Field(default=0.0) # Total AITBC allocated to reward participants
status: TrainingStatus = Field(default=TrainingStatus.INITIALIZED, index=True)
global_model_cid: Optional[str] = Field(default=None) # Final aggregated model
global_model_cid: str | None = Field(default=None) # Final aggregated model
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -59,63 +62,69 @@ class FederatedLearningSession(SQLModel, table=True):
# DISABLED: participants: List["TrainingParticipant"] = Relationship(back_populates="session")
# DISABLED: rounds: List["TrainingRound"] = Relationship(back_populates="session")
class TrainingParticipant(SQLModel, table=True):
"""An agent participating in a federated learning session"""
__tablename__ = "training_participant"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
session_id: str = Field(foreign_key="federated_learning_session.id", index=True)
agent_id: str = Field(index=True)
status: ParticipantStatus = Field(default=ParticipantStatus.JOINED, index=True)
data_samples_count: int = Field(default=0) # Claimed number of local samples used
compute_power_committed: float = Field(default=0.0) # TFLOPS
data_samples_count: int = Field(default=0) # Claimed number of local samples used
compute_power_committed: float = Field(default=0.0) # TFLOPS
reputation_score_at_join: float = Field(default=0.0)
earned_reward: float = Field(default=0.0)
joined_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: session: FederatedLearningSession = Relationship(back_populates="participants")
class TrainingRound(SQLModel, table=True):
"""A specific round of federated learning"""
__tablename__ = "training_round"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
session_id: str = Field(foreign_key="federated_learning_session.id", index=True)
round_number: int = Field()
status: str = Field(default="pending") # pending, active, aggregating, completed
starting_model_cid: str = Field() # Global model weights at start of round
aggregated_model_cid: Optional[str] = Field(default=None) # Resulting weights after round
metrics: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON)) # e.g. loss, accuracy
status: str = Field(default="pending") # pending, active, aggregating, completed
starting_model_cid: str = Field() # Global model weights at start of round
aggregated_model_cid: str | None = Field(default=None) # Resulting weights after round
metrics: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON)) # e.g. loss, accuracy
started_at: datetime = Field(default_factory=datetime.utcnow)
completed_at: Optional[datetime] = Field(default=None)
completed_at: datetime | None = Field(default=None)
# Relationships
# DISABLED: session: FederatedLearningSession = Relationship(back_populates="rounds")
# DISABLED: updates: List["LocalModelUpdate"] = Relationship(back_populates="round")
class LocalModelUpdate(SQLModel, table=True):
"""A local model update submitted by a participant for a specific round"""
__tablename__ = "local_model_update"
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
round_id: str = Field(foreign_key="training_round.id", index=True)
participant_agent_id: str = Field(index=True)
weights_cid: str = Field() # IPFS CID of the locally trained weights
zk_proof_hash: Optional[str] = Field(default=None) # Proof that training was executed correctly
weights_cid: str = Field() # IPFS CID of the locally trained weights
zk_proof_hash: str | None = Field(default=None) # Proof that training was executed correctly
is_aggregated: bool = Field(default=False)
rejected_reason: Optional[str] = Field(default=None) # e.g. "outlier", "failed zk verification"
rejected_reason: str | None = Field(default=None) # e.g. "outlier", "failed zk verification"
submitted_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships

327
apps/coordinator-api/src/app/domain/global_marketplace.py
View File

@@ -5,20 +5,18 @@ Domain models for global marketplace operations, multi-region support, and cross
from __future__ import annotations
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON, Index, Relationship
from sqlalchemy import DateTime, func
from .marketplace import MarketplaceOffer, MarketplaceBid
from .agent_identity import AgentIdentity
from sqlalchemy import Index
from sqlmodel import JSON, Column, Field, SQLModel
class MarketplaceStatus(str, Enum):
class MarketplaceStatus(StrEnum):
"""Global marketplace offer status"""
ACTIVE = "active"
INACTIVE = "inactive"
PENDING = "pending"
@@ -27,8 +25,9 @@ class MarketplaceStatus(str, Enum):
EXPIRED = "expired"
class RegionStatus(str, Enum):
class RegionStatus(StrEnum):
"""Global marketplace region status"""
ACTIVE = "active"
INACTIVE = "inactive"
MAINTENANCE = "maintenance"
@@ -37,329 +36,350 @@ class RegionStatus(str, Enum):
class MarketplaceRegion(SQLModel, table=True):
"""Global marketplace region configuration"""
__tablename__ = "marketplace_regions"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"region_{uuid4().hex[:8]}", primary_key=True)
region_code: str = Field(index=True, unique=True) # us-east-1, eu-west-1, etc.
region_name: str = Field(index=True)
geographic_area: str = Field(default="global")
# Configuration
base_currency: str = Field(default="USD")
timezone: str = Field(default="UTC")
language: str = Field(default="en")
# Load balancing
load_factor: float = Field(default=1.0, ge=0.1, le=10.0)
max_concurrent_requests: int = Field(default=1000)
priority_weight: float = Field(default=1.0, ge=0.1, le=10.0)
# Status and health
status: RegionStatus = Field(default=RegionStatus.ACTIVE)
health_score: float = Field(default=1.0, ge=0.0, le=1.0)
last_health_check: Optional[datetime] = Field(default=None)
last_health_check: datetime | None = Field(default=None)
# API endpoints
api_endpoint: str = Field(default="")
websocket_endpoint: str = Field(default="")
blockchain_rpc_endpoints: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
blockchain_rpc_endpoints: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
# Performance metrics
average_response_time: float = Field(default=0.0)
request_rate: float = Field(default=0.0)
error_rate: float = Field(default=0.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Indexes
__table_args__ = (
Index('idx_marketplace_region_code', 'region_code'),
Index('idx_marketplace_region_status', 'status'),
Index('idx_marketplace_region_health', 'health_score'),
)
__table_args__ = {
"extend_existing": True,
"indexes": [
Index("idx_marketplace_region_code", "region_code"),
Index("idx_marketplace_region_status", "status"),
Index("idx_marketplace_region_health", "health_score"),
]
}
class GlobalMarketplaceConfig(SQLModel, table=True):
"""Global marketplace configuration settings"""
__tablename__ = "global_marketplace_configs"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"config_{uuid4().hex[:8]}", primary_key=True)
config_key: str = Field(index=True, unique=True)
config_value: str = Field(default="") # Changed from Any to str
config_type: str = Field(default="string") # string, number, boolean, json
# Configuration metadata
description: str = Field(default="")
category: str = Field(default="general")
is_public: bool = Field(default=False)
is_encrypted: bool = Field(default=False)
# Validation rules
min_value: Optional[float] = Field(default=None)
max_value: Optional[float] = Field(default=None)
allowed_values: List[str] = Field(default_factory=list, sa_column=Column(JSON))
min_value: float | None = Field(default=None)
max_value: float | None = Field(default=None)
allowed_values: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_modified_by: Optional[str] = Field(default=None)
last_modified_by: str | None = Field(default=None)
# Indexes
__table_args__ = (
Index('idx_global_config_key', 'config_key'),
Index('idx_global_config_category', 'category'),
)
__table_args__ = {
"extend_existing": True,
"indexes": [
Index("idx_global_config_key", "config_key"),
Index("idx_global_config_category", "category"),
]
}
class GlobalMarketplaceOffer(SQLModel, table=True):
"""Global marketplace offer with multi-region support"""
__tablename__ = "global_marketplace_offers"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"offer_{uuid4().hex[:8]}", primary_key=True)
original_offer_id: str = Field(index=True) # Reference to original marketplace offer
# Global offer data
agent_id: str = Field(index=True)
service_type: str = Field(index=True) # gpu, compute, storage, etc.
resource_specification: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
resource_specification: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Pricing (multi-currency support)
base_price: float = Field(default=0.0)
currency: str = Field(default="USD")
price_per_region: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
price_per_region: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
dynamic_pricing_enabled: bool = Field(default=False)
# Availability
total_capacity: int = Field(default=0)
available_capacity: int = Field(default=0)
regions_available: List[str] = Field(default_factory=list, sa_column=Column(JSON))
regions_available: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Global status
global_status: MarketplaceStatus = Field(default=MarketplaceStatus.ACTIVE)
region_statuses: Dict[str, MarketplaceStatus] = Field(default_factory=dict, sa_column=Column(JSON))
region_statuses: dict[str, MarketplaceStatus] = Field(default_factory=dict, sa_column=Column(JSON))
# Quality metrics
global_rating: float = Field(default=0.0, ge=0.0, le=5.0)
total_transactions: int = Field(default=0)
success_rate: float = Field(default=0.0, ge=0.0, le=1.0)
# Cross-chain support
supported_chains: List[int] = Field(default_factory=list, sa_column=Column(JSON))
cross_chain_pricing: Dict[int, float] = Field(default_factory=dict, sa_column=Column(JSON))
supported_chains: list[int] = Field(default_factory=list, sa_column=Column(JSON))
cross_chain_pricing: dict[int, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = Field(default=None)
expires_at: datetime | None = Field(default=None)
# Indexes
__table_args__ = (
Index('idx_global_offer_agent', 'agent_id'),
Index('idx_global_offer_service', 'service_type'),
Index('idx_global_offer_status', 'global_status'),
Index('idx_global_offer_created', 'created_at'),
)
__table_args__ = {
"extend_existing": True,
"indexes": [
Index("idx_global_offer_agent", "agent_id"),
Index("idx_global_offer_service", "service_type"),
Index("idx_global_offer_status", "global_status"),
Index("idx_global_offer_created", "created_at"),
]
}
class GlobalMarketplaceTransaction(SQLModel, table=True):
"""Global marketplace transaction with cross-chain support"""
__tablename__ = "global_marketplace_transactions"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"tx_{uuid4().hex[:8]}", primary_key=True)
transaction_hash: Optional[str] = Field(index=True)
transaction_hash: str | None = Field(index=True)
# Transaction participants
buyer_id: str = Field(index=True)
seller_id: str = Field(index=True)
offer_id: str = Field(index=True)
# Transaction details
service_type: str = Field(index=True)
quantity: int = Field(default=1)
unit_price: float = Field(default=0.0)
total_amount: float = Field(default=0.0)
currency: str = Field(default="USD")
# Cross-chain information
source_chain: Optional[int] = Field(default=None)
target_chain: Optional[int] = Field(default=None)
bridge_transaction_id: Optional[str] = Field(default=None)
source_chain: int | None = Field(default=None)
target_chain: int | None = Field(default=None)
bridge_transaction_id: str | None = Field(default=None)
cross_chain_fee: float = Field(default=0.0)
# Regional information
source_region: str = Field(default="global")
target_region: str = Field(default="global")
regional_fees: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
regional_fees: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Transaction status
status: str = Field(default="pending") # pending, confirmed, completed, failed, cancelled
payment_status: str = Field(default="pending") # pending, paid, refunded
delivery_status: str = Field(default="pending") # pending, delivered, failed
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
confirmed_at: Optional[datetime] = Field(default=None)
completed_at: Optional[datetime] = Field(default=None)
confirmed_at: datetime | None = Field(default=None)
completed_at: datetime | None = Field(default=None)
# Transaction metadata
transaction_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
transaction_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Indexes
__table_args__ = (
Index('idx_global_tx_buyer', 'buyer_id'),
Index('idx_global_tx_seller', 'seller_id'),
Index('idx_global_tx_offer', 'offer_id'),
Index('idx_global_tx_status', 'status'),
Index('idx_global_tx_created', 'created_at'),
Index('idx_global_tx_chain', 'source_chain', 'target_chain'),
)
__table_args__ = {
"extend_existing": True,
"indexes": [
Index("idx_global_tx_buyer", "buyer_id"),
Index("idx_global_tx_seller", "seller_id"),
Index("idx_global_tx_offer", "offer_id"),
Index("idx_global_tx_status", "status"),
Index("idx_global_tx_created", "created_at"),
Index("idx_global_tx_chain", "source_chain", "target_chain"),
]
}
class GlobalMarketplaceAnalytics(SQLModel, table=True):
"""Global marketplace analytics and metrics"""
__tablename__ = "global_marketplace_analytics"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"analytics_{uuid4().hex[:8]}", primary_key=True)
# Analytics period
period_type: str = Field(default="hourly") # hourly, daily, weekly, monthly
period_start: datetime = Field(index=True)
period_end: datetime = Field(index=True)
region: Optional[str] = Field(default="global", index=True)
region: str | None = Field(default="global", index=True)
# Marketplace metrics
total_offers: int = Field(default=0)
total_transactions: int = Field(default=0)
total_volume: float = Field(default=0.0)
average_price: float = Field(default=0.0)
# Performance metrics
average_response_time: float = Field(default=0.0)
success_rate: float = Field(default=0.0)
error_rate: float = Field(default=0.0)
# User metrics
active_buyers: int = Field(default=0)
active_sellers: int = Field(default=0)
new_users: int = Field(default=0)
# Cross-chain metrics
cross_chain_transactions: int = Field(default=0)
cross_chain_volume: float = Field(default=0.0)
supported_chains: List[int] = Field(default_factory=list, sa_column=Column(JSON))
supported_chains: list[int] = Field(default_factory=list, sa_column=Column(JSON))
# Regional metrics
regional_distribution: Dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
regional_performance: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
regional_distribution: dict[str, int] = Field(default_factory=dict, sa_column=Column(JSON))
regional_performance: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Additional analytics data
analytics_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
analytics_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Indexes
__table_args__ = (
Index('idx_global_analytics_period', 'period_type', 'period_start'),
Index('idx_global_analytics_region', 'region'),
Index('idx_global_analytics_created', 'created_at'),
)
__table_args__ = {
"extend_existing": True,
"indexes": [
Index("idx_global_analytics_period", "period_type", "period_start"),
Index("idx_global_analytics_region", "region"),
Index("idx_global_analytics_created", "created_at"),
]
}
class GlobalMarketplaceGovernance(SQLModel, table=True):
"""Global marketplace governance and rules"""
__tablename__ = "global_marketplace_governance"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"gov_{uuid4().hex[:8]}", primary_key=True)
# Governance rule
rule_type: str = Field(index=True) # pricing, security, compliance, quality
rule_name: str = Field(index=True)
rule_description: str = Field(default="")
# Rule configuration
rule_parameters: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
conditions: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
rule_parameters: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
conditions: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Scope and applicability
global_scope: bool = Field(default=True)
applicable_regions: List[str] = Field(default_factory=list, sa_column=Column(JSON))
applicable_services: List[str] = Field(default_factory=list, sa_column=Column(JSON))
applicable_regions: list[str] = Field(default_factory=list, sa_column=Column(JSON))
applicable_services: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Enforcement
is_active: bool = Field(default=True)
enforcement_level: str = Field(default="warning") # warning, restriction, ban
penalty_parameters: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
penalty_parameters: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Governance metadata
created_by: str = Field(default="")
approved_by: Optional[str] = Field(default=None)
approved_by: str | None = Field(default=None)
version: int = Field(default=1)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
effective_from: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = Field(default=None)
expires_at: datetime | None = Field(default=None)
# Indexes
__table_args__ = (
Index('idx_global_gov_rule_type', 'rule_type'),
Index('idx_global_gov_active', 'is_active'),
Index('idx_global_gov_effective', 'effective_from', 'expires_at'),
)
__table_args__ = {
"extend_existing": True,
"indexes": [
Index("idx_global_gov_rule_type", "rule_type"),
Index("idx_global_gov_active", "is_active"),
Index("idx_global_gov_effective", "effective_from", "expires_at"),
]
}
# Request/Response Models for API
class GlobalMarketplaceOfferRequest(SQLModel):
"""Request model for creating global marketplace offers"""
agent_id: str
service_type: str
resource_specification: Dict[str, Any]
resource_specification: dict[str, Any]
base_price: float
currency: str = "USD"
total_capacity: int
regions_available: List[str] = []
supported_chains: List[int] = []
regions_available: list[str] = []
supported_chains: list[int] = []
dynamic_pricing_enabled: bool = False
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
class GlobalMarketplaceTransactionRequest(SQLModel):
"""Request model for creating global marketplace transactions"""
buyer_id: str
offer_id: str
quantity: int = 1
source_region: str = "global"
target_region: str = "global"
payment_method: str = "crypto"
source_chain: Optional[int] = None
target_chain: Optional[int] = None
source_chain: int | None = None
target_chain: int | None = None
class GlobalMarketplaceAnalyticsRequest(SQLModel):
"""Request model for global marketplace analytics"""
period_type: str = "daily"
start_date: datetime
end_date: datetime
region: Optional[str] = "global"
metrics: List[str] = []
region: str | None = "global"
metrics: list[str] = []
include_cross_chain: bool = False
include_regional: bool = False
@@ -367,31 +387,33 @@ class GlobalMarketplaceAnalyticsRequest(SQLModel):
# Response Models
class GlobalMarketplaceOfferResponse(SQLModel):
"""Response model for global marketplace offers"""
id: str
agent_id: str
service_type: str
resource_specification: Dict[str, Any]
resource_specification: dict[str, Any]
base_price: float
currency: str
price_per_region: Dict[str, float]
price_per_region: dict[str, float]
total_capacity: int
available_capacity: int
regions_available: List[str]
regions_available: list[str]
global_status: MarketplaceStatus
global_rating: float
total_transactions: int
success_rate: float
supported_chains: List[int]
cross_chain_pricing: Dict[int, float]
supported_chains: list[int]
cross_chain_pricing: dict[int, float]
created_at: datetime
updated_at: datetime
expires_at: Optional[datetime]
expires_at: datetime | None
class GlobalMarketplaceTransactionResponse(SQLModel):
"""Response model for global marketplace transactions"""
id: str
transaction_hash: Optional[str]
transaction_hash: str | None
buyer_id: str
seller_id: str
offer_id: str
@@ -400,8 +422,8 @@ class GlobalMarketplaceTransactionResponse(SQLModel):
unit_price: float
total_amount: float
currency: str
source_chain: Optional[int]
target_chain: Optional[int]
source_chain: int | None
target_chain: int | None
cross_chain_fee: float
source_region: str
target_region: str
@@ -410,12 +432,13 @@ class GlobalMarketplaceTransactionResponse(SQLModel):
delivery_status: str
created_at: datetime
updated_at: datetime
confirmed_at: Optional[datetime]
completed_at: Optional[datetime]
confirmed_at: datetime | None
completed_at: datetime | None
class GlobalMarketplaceAnalyticsResponse(SQLModel):
"""Response model for global marketplace analytics"""
period_type: str
period_start: datetime
period_end: datetime
@@ -430,6 +453,6 @@ class GlobalMarketplaceAnalyticsResponse(SQLModel):
active_sellers: int
cross_chain_transactions: int
cross_chain_volume: float
regional_distribution: Dict[str, int]
regional_performance: Dict[str, float]
regional_distribution: dict[str, int]
regional_performance: dict[str, float]
generated_at: datetime

96
apps/coordinator-api/src/app/domain/governance.py
View File

@@ -3,13 +3,15 @@ Decentralized Governance Models
Database models for OpenClaw DAO, voting, proposals, and governance analytics
"""
from typing import Optional, List, Dict, Any
from sqlmodel import Field, SQLModel, Column, JSON, Relationship
from datetime import datetime
from enum import Enum
import uuid
from datetime import datetime
from enum import StrEnum
from typing import Any
class ProposalStatus(str, Enum):
from sqlmodel import JSON, Column, Field, SQLModel
class ProposalStatus(StrEnum):
DRAFT = "draft"
ACTIVE = "active"
SUCCEEDED = "succeeded"
@@ -17,111 +19,123 @@ class ProposalStatus(str, Enum):
EXECUTED = "executed"
CANCELLED = "cancelled"
class VoteType(str, Enum):
class VoteType(StrEnum):
FOR = "for"
AGAINST = "against"
ABSTAIN = "abstain"
class GovernanceRole(str, Enum):
class GovernanceRole(StrEnum):
MEMBER = "member"
DELEGATE = "delegate"
COUNCIL = "council"
ADMIN = "admin"
class GovernanceProfile(SQLModel, table=True):
"""Profile for a participant in the AITBC DAO"""
__tablename__ = "governance_profiles"
profile_id: str = Field(primary_key=True, default_factory=lambda: f"gov_{uuid.uuid4().hex[:8]}")
user_id: str = Field(unique=True, index=True)
role: GovernanceRole = Field(default=GovernanceRole.MEMBER)
voting_power: float = Field(default=0.0) # Calculated based on staked AITBC and reputation
delegated_power: float = Field(default=0.0) # Power delegated to them by others
voting_power: float = Field(default=0.0) # Calculated based on staked AITBC and reputation
delegated_power: float = Field(default=0.0) # Power delegated to them by others
total_votes_cast: int = Field(default=0)
proposals_created: int = Field(default=0)
proposals_passed: int = Field(default=0)
delegate_to: Optional[str] = Field(default=None) # Profile ID they delegate their vote to
delegate_to: str | None = Field(default=None) # Profile ID they delegate their vote to
joined_at: datetime = Field(default_factory=datetime.utcnow)
last_voted_at: Optional[datetime] = None
last_voted_at: datetime | None = None
class Proposal(SQLModel, table=True):
"""A governance proposal submitted to the DAO"""
__tablename__ = "proposals"
proposal_id: str = Field(primary_key=True, default_factory=lambda: f"prop_{uuid.uuid4().hex[:8]}")
proposer_id: str = Field(foreign_key="governance_profiles.profile_id")
title: str
description: str
category: str = Field(default="general") # parameters, funding, protocol, marketplace
execution_payload: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
category: str = Field(default="general") # parameters, funding, protocol, marketplace
execution_payload: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
status: ProposalStatus = Field(default=ProposalStatus.DRAFT)
votes_for: float = Field(default=0.0)
votes_against: float = Field(default=0.0)
votes_abstain: float = Field(default=0.0)
quorum_required: float = Field(default=0.0)
passing_threshold: float = Field(default=0.5) # Usually 50%
snapshot_block: Optional[int] = Field(default=None)
snapshot_timestamp: Optional[datetime] = Field(default=None)
passing_threshold: float = Field(default=0.5) # Usually 50%
snapshot_block: int | None = Field(default=None)
snapshot_timestamp: datetime | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow)
voting_starts: datetime
voting_ends: datetime
executed_at: Optional[datetime] = None
executed_at: datetime | None = None
class Vote(SQLModel, table=True):
"""A vote cast on a specific proposal"""
__tablename__ = "votes"
vote_id: str = Field(primary_key=True, default_factory=lambda: f"vote_{uuid.uuid4().hex[:8]}")
proposal_id: str = Field(foreign_key="proposals.proposal_id", index=True)
voter_id: str = Field(foreign_key="governance_profiles.profile_id")
vote_type: VoteType
voting_power_used: float
reason: Optional[str] = None
reason: str | None = None
power_at_snapshot: float = Field(default=0.0)
delegated_power_at_snapshot: float = Field(default=0.0)
created_at: datetime = Field(default_factory=datetime.utcnow)
class DaoTreasury(SQLModel, table=True):
"""Record of the DAO's treasury funds and allocations"""
__tablename__ = "dao_treasury"
treasury_id: str = Field(primary_key=True, default="main_treasury")
total_balance: float = Field(default=0.0)
allocated_funds: float = Field(default=0.0)
asset_breakdown: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
asset_breakdown: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
last_updated: datetime = Field(default_factory=datetime.utcnow)
class TransparencyReport(SQLModel, table=True):
"""Automated transparency and analytics report for the governance system"""
__tablename__ = "transparency_reports"
report_id: str = Field(primary_key=True, default_factory=lambda: f"rep_{uuid.uuid4().hex[:8]}")
period: str # e.g., "2026-Q1", "2026-02"
period: str # e.g., "2026-Q1", "2026-02"
total_proposals: int
passed_proposals: int
active_voters: int
total_voting_power_participated: float
treasury_inflow: float
treasury_outflow: float
metrics: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
metrics: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
generated_at: datetime = Field(default_factory=datetime.utcnow)

68
apps/coordinator-api/src/app/domain/gpu_marketplace.py
View File

@@ -3,28 +3,28 @@
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Optional
from enum import StrEnum
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class GPUArchitecture(str, Enum):
TURING = "turing" # RTX 20 series
AMPERE = "ampere" # RTX 30 series
class GPUArchitecture(StrEnum):
TURING = "turing" # RTX 20 series
AMPERE = "ampere" # RTX 30 series
ADA_LOVELACE = "ada_lovelace" # RTX 40 series
PASCAL = "pascal" # GTX 10 series
VOLTA = "volta" # Titan V, Tesla V100
PASCAL = "pascal" # GTX 10 series
VOLTA = "volta" # Titan V, Tesla V100
UNKNOWN = "unknown"
class GPURegistry(SQLModel, table=True):
"""Registered GPUs available in the marketplace."""
__tablename__ = "gpu_registry"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"gpu_{uuid4().hex[:8]}", primary_key=True)
miner_id: str = Field(index=True)
model: str = Field(index=True)
@@ -41,9 +41,10 @@ class GPURegistry(SQLModel, table=True):
class ConsumerGPUProfile(SQLModel, table=True):
"""Consumer GPU optimization profiles for edge computing"""
__tablename__ = "consumer_gpu_profiles"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"cgp_{uuid4().hex[:8]}", primary_key=True)
gpu_model: str = Field(index=True)
architecture: GPUArchitecture = Field(default=GPUArchitecture.UNKNOWN)
@@ -51,27 +52,27 @@ class ConsumerGPUProfile(SQLModel, table=True):
edge_optimized: bool = Field(default=False)
# Hardware specifications
cuda_cores: Optional[int] = Field(default=None)
memory_gb: Optional[int] = Field(default=None)
memory_bandwidth_gbps: Optional[float] = Field(default=None)
tensor_cores: Optional[int] = Field(default=None)
base_clock_mhz: Optional[int] = Field(default=None)
boost_clock_mhz: Optional[int] = Field(default=None)
cuda_cores: int | None = Field(default=None)
memory_gb: int | None = Field(default=None)
memory_bandwidth_gbps: float | None = Field(default=None)
tensor_cores: int | None = Field(default=None)
base_clock_mhz: int | None = Field(default=None)
boost_clock_mhz: int | None = Field(default=None)
# Edge optimization metrics
power_consumption_w: Optional[float] = Field(default=None)
thermal_design_power_w: Optional[float] = Field(default=None)
noise_level_db: Optional[float] = Field(default=None)
power_consumption_w: float | None = Field(default=None)
thermal_design_power_w: float | None = Field(default=None)
noise_level_db: float | None = Field(default=None)
# Performance characteristics
fp32_tflops: Optional[float] = Field(default=None)
fp16_tflops: Optional[float] = Field(default=None)
int8_tops: Optional[float] = Field(default=None)
fp32_tflops: float | None = Field(default=None)
fp16_tflops: float | None = Field(default=None)
int8_tops: float | None = Field(default=None)
# Edge-specific optimizations
low_latency_mode: bool = Field(default=False)
mobile_optimized: bool = Field(default=False)
thermal_throttling_resistance: Optional[float] = Field(default=None)
thermal_throttling_resistance: float | None = Field(default=None)
# Compatibility flags
supported_cuda_versions: list = Field(default_factory=list, sa_column=Column(JSON, nullable=True))
@@ -79,7 +80,7 @@ class ConsumerGPUProfile(SQLModel, table=True):
supported_ollama_models: list = Field(default_factory=list, sa_column=Column(JSON, nullable=True))
# Pricing and availability
market_price_usd: Optional[float] = Field(default=None)
market_price_usd: float | None = Field(default=None)
edge_premium_multiplier: float = Field(default=1.0)
availability_score: float = Field(default=1.0)
@@ -89,9 +90,10 @@ class ConsumerGPUProfile(SQLModel, table=True):
class EdgeGPUMetrics(SQLModel, table=True):
"""Real-time edge GPU performance metrics"""
__tablename__ = "edge_gpu_metrics"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"egm_{uuid4().hex[:8]}", primary_key=True)
gpu_id: str = Field(foreign_key="gpu_registry.id")
@@ -113,35 +115,37 @@ class EdgeGPUMetrics(SQLModel, table=True):
# Geographic and network info
region: str = Field()
city: Optional[str] = Field(default=None)
isp: Optional[str] = Field(default=None)
connection_type: Optional[str] = Field(default=None)
city: str | None = Field(default=None)
isp: str | None = Field(default=None)
connection_type: str | None = Field(default=None)
timestamp: datetime = Field(default_factory=datetime.utcnow, index=True)
class GPUBooking(SQLModel, table=True):
"""Active and historical GPU bookings."""
__tablename__ = "gpu_bookings"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"bk_{uuid4().hex[:10]}", primary_key=True)
gpu_id: str = Field(index=True)
client_id: str = Field(default="", index=True)
job_id: Optional[str] = Field(default=None, index=True)
job_id: str | None = Field(default=None, index=True)
duration_hours: float = Field(default=0.0)
total_cost: float = Field(default=0.0)
status: str = Field(default="active", index=True) # active, completed, cancelled
start_time: datetime = Field(default_factory=datetime.utcnow)
end_time: Optional[datetime] = Field(default=None)
end_time: datetime | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow, nullable=False)
class GPUReview(SQLModel, table=True):
"""Reviews for GPUs."""
__tablename__ = "gpu_reviews"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"rv_{uuid4().hex[:10]}", primary_key=True)
gpu_id: str = Field(index=True)
user_id: str = Field(default="")

29
apps/coordinator-api/src/app/domain/job.py
View File

@@ -1,39 +1,38 @@
from __future__ import annotations
from datetime import datetime
from typing import Optional
from typing import Any, Dict
from uuid import uuid4
from sqlalchemy import Column, JSON, String, ForeignKey
from sqlalchemy.orm import Mapped, relationship
from sqlalchemy import JSON, Column, ForeignKey, String
from sqlmodel import Field, SQLModel
class Job(SQLModel, table=True):
__tablename__ = "job"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True, index=True)
client_id: str = Field(index=True)
state: str = Field(default="QUEUED", max_length=20)
payload: dict = Field(sa_column=Column(JSON, nullable=False))
constraints: dict = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
payload: Dict[str, Any] = Field(sa_column=Column(JSON, nullable=False))
constraints: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
ttl_seconds: int = Field(default=900)
requested_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: datetime = Field(default_factory=datetime.utcnow)
assigned_miner_id: Optional[str] = Field(default=None, index=True)
assigned_miner_id: str | None = Field(default=None, index=True)
result: Dict[str, Any] | None = Field(default=None, sa_column=Column(JSON, nullable=True))
receipt: Dict[str, Any] | None = Field(default=None, sa_column=Column(JSON, nullable=True))
receipt_id: str | None = Field(default=None, index=True)
error: str | None = None
result: Optional[dict] = Field(default=None, sa_column=Column(JSON, nullable=True))
receipt: Optional[dict] = Field(default=None, sa_column=Column(JSON, nullable=True))
receipt_id: Optional[str] = Field(default=None, index=True)
error: Optional[str] = None
# Payment tracking
payment_id: Optional[str] = Field(default=None, sa_column=Column(String, ForeignKey("job_payments.id"), index=True))
payment_status: Optional[str] = Field(default=None, max_length=20) # pending, escrowed, released, refunded
payment_id: str | None = Field(default=None, sa_column=Column(String, ForeignKey("job_payments.id"), index=True))
payment_status: str | None = Field(default=None, max_length=20) # pending, escrowed, released, refunded
# Relationships
# payment: Mapped[Optional["JobPayment"]] = relationship(back_populates="jobs")

4
apps/coordinator-api/src/app/domain/job_receipt.py
View File

@@ -3,14 +3,14 @@ from __future__ import annotations
from datetime import datetime
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class JobReceipt(SQLModel, table=True):
__tablename__ = "jobreceipt"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True, index=True)
job_id: str = Field(index=True, foreign_key="job.id")
receipt_id: str = Field(index=True)

21
apps/coordinator-api/src/app/domain/marketplace.py
View File

@@ -1,17 +1,16 @@
from __future__ import annotations
from datetime import datetime
from typing import Optional
from uuid import uuid4
from sqlalchemy import Column, JSON
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class MarketplaceOffer(SQLModel, table=True):
__tablename__ = "marketplaceoffer"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
provider: str = Field(index=True)
capacity: int = Field(default=0, nullable=False)
@@ -21,22 +20,22 @@ class MarketplaceOffer(SQLModel, table=True):
created_at: datetime = Field(default_factory=datetime.utcnow, nullable=False, index=True)
attributes: dict = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
# GPU-specific fields
gpu_model: Optional[str] = Field(default=None, index=True)
gpu_memory_gb: Optional[int] = Field(default=None)
gpu_count: Optional[int] = Field(default=1)
cuda_version: Optional[str] = Field(default=None)
price_per_hour: Optional[float] = Field(default=None)
region: Optional[str] = Field(default=None, index=True)
gpu_model: str | None = Field(default=None, index=True)
gpu_memory_gb: int | None = Field(default=None)
gpu_count: int | None = Field(default=1)
cuda_version: str | None = Field(default=None)
price_per_hour: float | None = Field(default=None)
region: str | None = Field(default=None, index=True)
class MarketplaceBid(SQLModel, table=True):
__tablename__ = "marketplacebid"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True)
provider: str = Field(index=True)
capacity: int = Field(default=0, nullable=False)
price: float = Field(default=0.0, nullable=False)
notes: Optional[str] = Field(default=None)
notes: str | None = Field(default=None)
status: str = Field(default="pending", nullable=False)
submitted_at: datetime = Field(default_factory=datetime.utcnow, nullable=False, index=True)

18
apps/coordinator-api/src/app/domain/miner.py
View File

@@ -1,28 +1,28 @@
from __future__ import annotations
from datetime import datetime
from typing import Optional
from typing import Any, Dict
from sqlalchemy import Column, JSON
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class Miner(SQLModel, table=True):
__tablename__ = "miner"
__table_args__ = {"extend_existing": True}
id: str = Field(primary_key=True, index=True)
region: Optional[str] = Field(default=None, index=True)
capabilities: dict = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
region: str | None = Field(default=None, index=True)
capabilities: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
concurrency: int = Field(default=1)
status: str = Field(default="ONLINE", index=True)
inflight: int = Field(default=0)
extra_metadata: dict = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
extra_metadata: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON, nullable=False))
last_heartbeat: datetime = Field(default_factory=datetime.utcnow, index=True)
session_token: Optional[str] = None
last_job_at: Optional[datetime] = Field(default=None, index=True)
session_token: str | None = None
last_job_at: datetime | None = Field(default=None, index=True)
jobs_completed: int = Field(default=0)
jobs_failed: int = Field(default=0)
total_job_duration_ms: int = Field(default=0)
average_job_duration_ms: float = Field(default=0.0)
last_receipt_id: Optional[str] = Field(default=None, index=True)
last_receipt_id: str | None = Field(default=None, index=True)

54
apps/coordinator-api/src/app/domain/payment.py
View File

@@ -3,73 +3,71 @@
from __future__ import annotations
from datetime import datetime
from typing import Optional, List
from uuid import uuid4
from sqlalchemy import Column, String, DateTime, Numeric, ForeignKey, JSON
from sqlalchemy.orm import Mapped, relationship
from sqlalchemy import JSON, Column, Numeric
from sqlmodel import Field, SQLModel
class JobPayment(SQLModel, table=True):
"""Payment record for a job"""
__tablename__ = "job_payments"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True, index=True)
job_id: str = Field(index=True)
# Payment details
amount: float = Field(sa_column=Column(Numeric(20, 8), nullable=False))
currency: str = Field(default="AITBC", max_length=10)
status: str = Field(default="pending", max_length=20)
payment_method: str = Field(default="aitbc_token", max_length=20)
# Addresses
escrow_address: Optional[str] = Field(default=None, max_length=100)
refund_address: Optional[str] = Field(default=None, max_length=100)
escrow_address: str | None = Field(default=None, max_length=100)
refund_address: str | None = Field(default=None, max_length=100)
# Transaction hashes
transaction_hash: Optional[str] = Field(default=None, max_length=100)
refund_transaction_hash: Optional[str] = Field(default=None, max_length=100)
transaction_hash: str | None = Field(default=None, max_length=100)
refund_transaction_hash: str | None = Field(default=None, max_length=100)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
escrowed_at: Optional[datetime] = None
released_at: Optional[datetime] = None
refunded_at: Optional[datetime] = None
expires_at: Optional[datetime] = None
escrowed_at: datetime | None = None
released_at: datetime | None = None
refunded_at: datetime | None = None
expires_at: datetime | None = None
# Additional metadata
meta_data: Optional[dict] = Field(default=None, sa_column=Column(JSON))
meta_data: dict | None = Field(default=None, sa_column=Column(JSON))
# Relationships
# jobs: Mapped[List["Job"]] = relationship(back_populates="payment")
class PaymentEscrow(SQLModel, table=True):
"""Escrow record for holding payments"""
__tablename__ = "payment_escrows"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: uuid4().hex, primary_key=True, index=True)
payment_id: str = Field(index=True)
# Escrow details
amount: float = Field(sa_column=Column(Numeric(20, 8), nullable=False))
currency: str = Field(default="AITBC", max_length=10)
address: str = Field(max_length=100)
# Status
is_active: bool = Field(default=True)
is_released: bool = Field(default=False)
is_refunded: bool = Field(default=False)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
released_at: Optional[datetime] = None
refunded_at: Optional[datetime] = None
expires_at: Optional[datetime] = None
released_at: datetime | None = None
refunded_at: datetime | None = None
expires_at: datetime | None = None

427
apps/coordinator-api/src/app/domain/pricing_models.py
View File

@@ -6,16 +6,17 @@ SQLModel definitions for pricing history, strategies, and market metrics
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Optional, Dict, Any, List
from enum import StrEnum
from typing import Any
from uuid import uuid4
from sqlalchemy import Column, JSON, Index
from sqlalchemy import JSON, Column, Index
from sqlmodel import Field, SQLModel, Text
class PricingStrategyType(str, Enum):
class PricingStrategyType(StrEnum):
"""Pricing strategy types for database"""
AGGRESSIVE_GROWTH = "aggressive_growth"
PROFIT_MAXIMIZATION = "profit_maximization"
MARKET_BALANCE = "market_balance"
@@ -28,8 +29,9 @@ class PricingStrategyType(str, Enum):
COMPETITOR_BASED = "competitor_based"
class ResourceType(str, Enum):
class ResourceType(StrEnum):
"""Resource types for pricing"""
GPU = "gpu"
SERVICE = "service"
STORAGE = "storage"
@@ -37,8 +39,9 @@ class ResourceType(str, Enum):
COMPUTE = "compute"
class PriceTrend(str, Enum):
class PriceTrend(StrEnum):
"""Price trend indicators"""
INCREASING = "increasing"
DECREASING = "decreasing"
STABLE = "stable"
@@ -48,6 +51,7 @@ class PriceTrend(str, Enum):
class PricingHistory(SQLModel, table=True):
"""Historical pricing data for analysis and machine learning"""
__tablename__ = "pricing_history"
__table_args__ = {
"extend_existing": True,
@@ -55,54 +59,55 @@ class PricingHistory(SQLModel, table=True):
Index("idx_pricing_history_resource_timestamp", "resource_id", "timestamp"),
Index("idx_pricing_history_type_region", "resource_type", "region"),
Index("idx_pricing_history_timestamp", "timestamp"),
Index("idx_pricing_history_provider", "provider_id")
]
Index("idx_pricing_history_provider", "provider_id"),
],
}
id: str = Field(default_factory=lambda: f"ph_{uuid4().hex[:12]}", primary_key=True)
resource_id: str = Field(index=True)
resource_type: ResourceType = Field(index=True)
provider_id: Optional[str] = Field(default=None, index=True)
provider_id: str | None = Field(default=None, index=True)
region: str = Field(default="global", index=True)
# Pricing data
price: float = Field(index=True)
base_price: float
price_change: Optional[float] = None # Change from previous price
price_change_percent: Optional[float] = None # Percentage change
price_change: float | None = None # Change from previous price
price_change_percent: float | None = None # Percentage change
# Market conditions at time of pricing
demand_level: float = Field(index=True)
supply_level: float = Field(index=True)
market_volatility: float
utilization_rate: float
# Strategy and factors
strategy_used: PricingStrategyType = Field(index=True)
strategy_parameters: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
pricing_factors: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
strategy_parameters: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
pricing_factors: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Performance metrics
confidence_score: float
forecast_accuracy: Optional[float] = None
recommendation_followed: Optional[bool] = None
forecast_accuracy: float | None = None
recommendation_followed: bool | None = None
# Metadata
timestamp: datetime = Field(default_factory=datetime.utcnow, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow)
# Additional context
competitor_prices: List[float] = Field(default_factory=list, sa_column=Column(JSON))
competitor_prices: list[float] = Field(default_factory=list, sa_column=Column(JSON))
market_sentiment: float = Field(default=0.0)
external_factors: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
external_factors: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Reasoning and audit trail
price_reasoning: List[str] = Field(default_factory=list, sa_column=Column(JSON))
audit_log: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
price_reasoning: list[str] = Field(default_factory=list, sa_column=Column(JSON))
audit_log: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
class ProviderPricingStrategy(SQLModel, table=True):
"""Provider pricing strategies and configurations"""
__tablename__ = "provider_pricing_strategies"
__table_args__ = {
"extend_existing": True,
@@ -110,61 +115,62 @@ class ProviderPricingStrategy(SQLModel, table=True):
Index("idx_provider_strategies_provider", "provider_id"),
Index("idx_provider_strategies_type", "strategy_type"),
Index("idx_provider_strategies_active", "is_active"),
Index("idx_provider_strategies_resource", "resource_type", "provider_id")
]
Index("idx_provider_strategies_resource", "resource_type", "provider_id"),
],
}
id: str = Field(default_factory=lambda: f"pps_{uuid4().hex[:12]}", primary_key=True)
provider_id: str = Field(index=True)
strategy_type: PricingStrategyType = Field(index=True)
resource_type: Optional[ResourceType] = Field(default=None, index=True)
resource_type: ResourceType | None = Field(default=None, index=True)
# Strategy configuration
strategy_name: str
strategy_description: Optional[str] = None
parameters: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
strategy_description: str | None = None
parameters: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Constraints and limits
min_price: Optional[float] = None
max_price: Optional[float] = None
min_price: float | None = None
max_price: float | None = None
max_change_percent: float = Field(default=0.5)
min_change_interval: int = Field(default=300) # seconds
strategy_lock_period: int = Field(default=3600) # seconds
# Strategy rules
rules: List[Dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
custom_conditions: List[str] = Field(default_factory=list, sa_column=Column(JSON))
rules: list[dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
custom_conditions: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Status and metadata
is_active: bool = Field(default=True, index=True)
auto_optimize: bool = Field(default=True)
learning_enabled: bool = Field(default=True)
priority: int = Field(default=5) # 1-10 priority level
# Geographic scope
regions: List[str] = Field(default_factory=list, sa_column=Column(JSON))
regions: list[str] = Field(default_factory=list, sa_column=Column(JSON))
global_strategy: bool = Field(default=True)
# Performance tracking
total_revenue_impact: float = Field(default=0.0)
market_share_impact: float = Field(default=0.0)
customer_satisfaction_impact: float = Field(default=0.0)
strategy_effectiveness_score: float = Field(default=0.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_applied: Optional[datetime] = None
expires_at: Optional[datetime] = None
last_applied: datetime | None = None
expires_at: datetime | None = None
# Audit information
created_by: Optional[str] = None
updated_by: Optional[str] = None
created_by: str | None = None
updated_by: str | None = None
version: int = Field(default=1)
class MarketMetrics(SQLModel, table=True):
"""Real-time and historical market metrics"""
__tablename__ = "market_metrics"
__table_args__ = {
"extend_existing": True,
@@ -173,62 +179,63 @@ class MarketMetrics(SQLModel, table=True):
Index("idx_market_metrics_timestamp", "timestamp"),
Index("idx_market_metrics_demand", "demand_level"),
Index("idx_market_metrics_supply", "supply_level"),
Index("idx_market_metrics_composite", "region", "resource_type", "timestamp")
]
Index("idx_market_metrics_composite", "region", "resource_type", "timestamp"),
],
}
id: str = Field(default_factory=lambda: f"mm_{uuid4().hex[:12]}", primary_key=True)
region: str = Field(index=True)
resource_type: ResourceType = Field(index=True)
# Core market metrics
demand_level: float = Field(index=True)
supply_level: float = Field(index=True)
average_price: float = Field(index=True)
price_volatility: float = Field(index=True)
utilization_rate: float = Field(index=True)
# Market depth and liquidity
total_capacity: float
available_capacity: float
pending_orders: int
completed_orders: int
order_book_depth: float
# Competitive landscape
competitor_count: int
average_competitor_price: float
price_spread: float # Difference between highest and lowest prices
market_concentration: float # HHI or similar metric
# Market sentiment and activity
market_sentiment: float = Field(default=0.0)
trading_volume: float
price_momentum: float # Rate of price change
liquidity_score: float
# Regional factors
regional_multiplier: float = Field(default=1.0)
currency_adjustment: float = Field(default=1.0)
regulatory_factors: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
regulatory_factors: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Data quality and confidence
data_sources: List[str] = Field(default_factory=list, sa_column=Column(JSON))
data_sources: list[str] = Field(default_factory=list, sa_column=Column(JSON))
confidence_score: float
data_freshness: int # Age of data in seconds
completeness_score: float
# Timestamps
timestamp: datetime = Field(default_factory=datetime.utcnow, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow)
# Additional metrics
custom_metrics: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
external_factors: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
custom_metrics: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
external_factors: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
class PriceForecast(SQLModel, table=True):
"""Price forecasting data and accuracy tracking"""
__tablename__ = "price_forecasts"
__table_args__ = {
"extend_existing": True,
@@ -236,53 +243,54 @@ class PriceForecast(SQLModel, table=True):
Index("idx_price_forecasts_resource", "resource_id"),
Index("idx_price_forecasts_target", "target_timestamp"),
Index("idx_price_forecasts_created", "created_at"),
Index("idx_price_forecasts_horizon", "forecast_horizon_hours")
]
Index("idx_price_forecasts_horizon", "forecast_horizon_hours"),
],
}
id: str = Field(default_factory=lambda: f"pf_{uuid4().hex[:12]}", primary_key=True)
resource_id: str = Field(index=True)
resource_type: ResourceType = Field(index=True)
region: str = Field(default="global", index=True)
# Forecast parameters
forecast_horizon_hours: int = Field(index=True)
model_version: str
strategy_used: PricingStrategyType
# Forecast data points
forecast_points: List[Dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
confidence_intervals: Dict[str, List[float]] = Field(default_factory=dict, sa_column=Column(JSON))
forecast_points: list[dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
confidence_intervals: dict[str, list[float]] = Field(default_factory=dict, sa_column=Column(JSON))
# Forecast metadata
average_forecast_price: float
price_range_forecast: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
price_range_forecast: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
trend_forecast: PriceTrend
volatility_forecast: float
# Model performance
model_confidence: float
accuracy_score: Optional[float] = None # Populated after actual prices are known
mean_absolute_error: Optional[float] = None
mean_absolute_percentage_error: Optional[float] = None
accuracy_score: float | None = None # Populated after actual prices are known
mean_absolute_error: float | None = None
mean_absolute_percentage_error: float | None = None
# Input data used for forecast
input_data_summary: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
market_conditions_at_forecast: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
input_data_summary: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
market_conditions_at_forecast: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
target_timestamp: datetime = Field(index=True) # When forecast is for
evaluated_at: Optional[datetime] = None # When forecast was evaluated
evaluated_at: datetime | None = None # When forecast was evaluated
# Status and outcomes
forecast_status: str = Field(default="pending") # pending, evaluated, expired
outcome: Optional[str] = None # accurate, inaccurate, mixed
lessons_learned: List[str] = Field(default_factory=list, sa_column=Column(JSON))
outcome: str | None = None # accurate, inaccurate, mixed
lessons_learned: list[str] = Field(default_factory=list, sa_column=Column(JSON))
class PricingOptimization(SQLModel, table=True):
"""Pricing optimization experiments and results"""
__tablename__ = "pricing_optimizations"
__table_args__ = {
"extend_existing": True,
@@ -290,64 +298,65 @@ class PricingOptimization(SQLModel, table=True):
Index("idx_pricing_opt_provider", "provider_id"),
Index("idx_pricing_opt_experiment", "experiment_id"),
Index("idx_pricing_opt_status", "status"),
Index("idx_pricing_opt_created", "created_at")
]
Index("idx_pricing_opt_created", "created_at"),
],
}
id: str = Field(default_factory=lambda: f"po_{uuid4().hex[:12]}", primary_key=True)
experiment_id: str = Field(index=True)
provider_id: str = Field(index=True)
resource_type: Optional[ResourceType] = Field(default=None, index=True)
resource_type: ResourceType | None = Field(default=None, index=True)
# Experiment configuration
experiment_name: str
experiment_type: str # ab_test, multivariate, optimization
hypothesis: str
control_strategy: PricingStrategyType
test_strategy: PricingStrategyType
# Experiment parameters
sample_size: int
confidence_level: float = Field(default=0.95)
statistical_power: float = Field(default=0.8)
minimum_detectable_effect: float
# Experiment scope
regions: List[str] = Field(default_factory=list, sa_column=Column(JSON))
regions: list[str] = Field(default_factory=list, sa_column=Column(JSON))
duration_days: int
start_date: datetime
end_date: Optional[datetime] = None
end_date: datetime | None = None
# Results
control_performance: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
test_performance: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
statistical_significance: Optional[float] = None
effect_size: Optional[float] = None
control_performance: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
test_performance: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
statistical_significance: float | None = None
effect_size: float | None = None
# Business impact
revenue_impact: Optional[float] = None
profit_impact: Optional[float] = None
market_share_impact: Optional[float] = None
customer_satisfaction_impact: Optional[float] = None
revenue_impact: float | None = None
profit_impact: float | None = None
market_share_impact: float | None = None
customer_satisfaction_impact: float | None = None
# Status and metadata
status: str = Field(default="planned") # planned, running, completed, failed
conclusion: Optional[str] = None
recommendations: List[str] = Field(default_factory=list, sa_column=Column(JSON))
conclusion: str | None = None
recommendations: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
updated_at: datetime = Field(default_factory=datetime.utcnow)
completed_at: Optional[datetime] = None
completed_at: datetime | None = None
# Audit trail
created_by: Optional[str] = None
reviewed_by: Optional[str] = None
approved_by: Optional[str] = None
created_by: str | None = None
reviewed_by: str | None = None
approved_by: str | None = None
class PricingAlert(SQLModel, table=True):
"""Pricing alerts and notifications"""
__tablename__ = "pricing_alerts"
__table_args__ = {
"extend_existing": True,
@@ -356,61 +365,62 @@ class PricingAlert(SQLModel, table=True):
Index("idx_pricing_alerts_type", "alert_type"),
Index("idx_pricing_alerts_status", "status"),
Index("idx_pricing_alerts_severity", "severity"),
Index("idx_pricing_alerts_created", "created_at")
]
Index("idx_pricing_alerts_created", "created_at"),
],
}
id: str = Field(default_factory=lambda: f"pa_{uuid4().hex[:12]}", primary_key=True)
provider_id: Optional[str] = Field(default=None, index=True)
resource_id: Optional[str] = Field(default=None, index=True)
resource_type: Optional[ResourceType] = Field(default=None, index=True)
provider_id: str | None = Field(default=None, index=True)
resource_id: str | None = Field(default=None, index=True)
resource_type: ResourceType | None = Field(default=None, index=True)
# Alert details
alert_type: str = Field(index=True) # price_volatility, strategy_performance, market_change, etc.
severity: str = Field(index=True) # low, medium, high, critical
title: str
description: str
# Alert conditions
trigger_conditions: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
threshold_values: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
actual_values: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
trigger_conditions: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
threshold_values: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
actual_values: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Alert context
market_conditions: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
strategy_context: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
historical_context: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
market_conditions: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
strategy_context: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
historical_context: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Recommendations and actions
recommendations: List[str] = Field(default_factory=list, sa_column=Column(JSON))
automated_actions_taken: List[str] = Field(default_factory=list, sa_column=Column(JSON))
manual_actions_required: List[str] = Field(default_factory=list, sa_column=Column(JSON))
recommendations: list[str] = Field(default_factory=list, sa_column=Column(JSON))
automated_actions_taken: list[str] = Field(default_factory=list, sa_column=Column(JSON))
manual_actions_required: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Status and resolution
status: str = Field(default="active") # active, acknowledged, resolved, dismissed
resolution: Optional[str] = None
resolution_notes: Optional[str] = Field(default=None, sa_column=Text)
resolution: str | None = None
resolution_notes: str | None = Field(default=None, sa_column=Text)
# Impact assessment
business_impact: Optional[str] = None
revenue_impact_estimate: Optional[float] = None
customer_impact_estimate: Optional[str] = None
business_impact: str | None = None
revenue_impact_estimate: float | None = None
customer_impact_estimate: str | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow, index=True)
first_seen: datetime = Field(default_factory=datetime.utcnow)
last_seen: datetime = Field(default_factory=datetime.utcnow)
acknowledged_at: Optional[datetime] = None
resolved_at: Optional[datetime] = None
acknowledged_at: datetime | None = None
resolved_at: datetime | None = None
# Communication
notification_sent: bool = Field(default=False)
notification_channels: List[str] = Field(default_factory=list, sa_column=Column(JSON))
notification_channels: list[str] = Field(default_factory=list, sa_column=Column(JSON))
escalation_level: int = Field(default=0)
class PricingRule(SQLModel, table=True):
"""Custom pricing rules and conditions"""
__tablename__ = "pricing_rules"
__table_args__ = {
"extend_existing": True,
@@ -418,61 +428,62 @@ class PricingRule(SQLModel, table=True):
Index("idx_pricing_rules_provider", "provider_id"),
Index("idx_pricing_rules_strategy", "strategy_id"),
Index("idx_pricing_rules_active", "is_active"),
Index("idx_pricing_rules_priority", "priority")
]
Index("idx_pricing_rules_priority", "priority"),
],
}
id: str = Field(default_factory=lambda: f"pr_{uuid4().hex[:12]}", primary_key=True)
provider_id: Optional[str] = Field(default=None, index=True)
strategy_id: Optional[str] = Field(default=None, index=True)
provider_id: str | None = Field(default=None, index=True)
strategy_id: str | None = Field(default=None, index=True)
# Rule definition
rule_name: str
rule_description: Optional[str] = None
rule_description: str | None = None
rule_type: str # condition, action, constraint, optimization
# Rule logic
condition_expression: str = Field(..., description="Logical condition for rule")
action_expression: str = Field(..., description="Action to take when condition is met")
priority: int = Field(default=5, index=True) # 1-10 priority
# Rule scope
resource_types: List[ResourceType] = Field(default_factory=list, sa_column=Column(JSON))
regions: List[str] = Field(default_factory=list, sa_column=Column(JSON))
time_conditions: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
resource_types: list[ResourceType] = Field(default_factory=list, sa_column=Column(JSON))
regions: list[str] = Field(default_factory=list, sa_column=Column(JSON))
time_conditions: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Rule parameters
parameters: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
thresholds: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
multipliers: Dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
parameters: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
thresholds: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
multipliers: dict[str, float] = Field(default_factory=dict, sa_column=Column(JSON))
# Status and execution
is_active: bool = Field(default=True, index=True)
execution_count: int = Field(default=0)
success_count: int = Field(default=0)
failure_count: int = Field(default=0)
last_executed: Optional[datetime] = None
last_success: Optional[datetime] = None
last_executed: datetime | None = None
last_success: datetime | None = None
# Performance metrics
average_execution_time: Optional[float] = None
average_execution_time: float | None = None
success_rate: float = Field(default=1.0)
business_impact: Optional[float] = None
business_impact: float | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
# Audit trail
created_by: Optional[str] = None
updated_by: Optional[str] = None
created_by: str | None = None
updated_by: str | None = None
version: int = Field(default=1)
change_log: List[Dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
change_log: list[dict[str, Any]] = Field(default_factory=list, sa_column=Column(JSON))
class PricingAuditLog(SQLModel, table=True):
"""Audit log for pricing changes and decisions"""
__tablename__ = "pricing_audit_log"
__table_args__ = {
"extend_existing": True,
@@ -481,61 +492,62 @@ class PricingAuditLog(SQLModel, table=True):
Index("idx_pricing_audit_resource", "resource_id"),
Index("idx_pricing_audit_action", "action_type"),
Index("idx_pricing_audit_timestamp", "timestamp"),
Index("idx_pricing_audit_user", "user_id")
]
Index("idx_pricing_audit_user", "user_id"),
],
}
id: str = Field(default_factory=lambda: f"pal_{uuid4().hex[:12]}", primary_key=True)
provider_id: Optional[str] = Field(default=None, index=True)
resource_id: Optional[str] = Field(default=None, index=True)
user_id: Optional[str] = Field(default=None, index=True)
provider_id: str | None = Field(default=None, index=True)
resource_id: str | None = Field(default=None, index=True)
user_id: str | None = Field(default=None, index=True)
# Action details
action_type: str = Field(index=True) # price_change, strategy_update, rule_creation, etc.
action_description: str
action_source: str # manual, automated, api, system
# State changes
before_state: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
after_state: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
changed_fields: List[str] = Field(default_factory=list, sa_column=Column(JSON))
before_state: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
after_state: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
changed_fields: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# Context and reasoning
decision_reasoning: Optional[str] = Field(default=None, sa_column=Text)
market_conditions: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
business_context: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
decision_reasoning: str | None = Field(default=None, sa_column=Text)
market_conditions: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
business_context: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
# Impact and outcomes
immediate_impact: Optional[Dict[str, float]] = Field(default_factory=dict, sa_column=Column(JSON))
expected_impact: Optional[Dict[str, float]] = Field(default_factory=dict, sa_column=Column(JSON))
actual_impact: Optional[Dict[str, float]] = Field(default_factory=dict, sa_column=Column(JSON))
immediate_impact: dict[str, float] | None = Field(default_factory=dict, sa_column=Column(JSON))
expected_impact: dict[str, float] | None = Field(default_factory=dict, sa_column=Column(JSON))
actual_impact: dict[str, float] | None = Field(default_factory=dict, sa_column=Column(JSON))
# Compliance and approval
compliance_flags: List[str] = Field(default_factory=list, sa_column=Column(JSON))
compliance_flags: list[str] = Field(default_factory=list, sa_column=Column(JSON))
approval_required: bool = Field(default=False)
approved_by: Optional[str] = None
approved_at: Optional[datetime] = None
approved_by: str | None = None
approved_at: datetime | None = None
# Technical details
api_endpoint: Optional[str] = None
request_id: Optional[str] = None
session_id: Optional[str] = None
ip_address: Optional[str] = None
api_endpoint: str | None = None
request_id: str | None = None
session_id: str | None = None
ip_address: str | None = None
# Timestamps
timestamp: datetime = Field(default_factory=datetime.utcnow, index=True)
created_at: datetime = Field(default_factory=datetime.utcnow)
# Additional metadata
meta_data: Dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
tags: List[str] = Field(default_factory=list, sa_column=Column(JSON))
meta_data: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
tags: list[str] = Field(default_factory=list, sa_column=Column(JSON))
# View definitions for common queries
class PricingSummaryView(SQLModel):
"""View for pricing summary analytics"""
__tablename__ = "pricing_summary_view"
provider_id: str
resource_type: ResourceType
region: str
@@ -552,8 +564,9 @@ class PricingSummaryView(SQLModel):
class MarketHeatmapView(SQLModel):
"""View for market heatmap data"""
__tablename__ = "market_heatmap_view"
region: str
resource_type: ResourceType
demand_level: float

305
apps/coordinator-api/src/app/domain/pricing_strategies.py
View File

@@ -4,14 +4,14 @@ Defines various pricing strategies and their configurations for dynamic pricing
"""
from dataclasses import dataclass, field
from typing import Dict, List, Any, Optional
from enum import Enum
from datetime import datetime
import json
from enum import StrEnum
from typing import Any
class PricingStrategy(str, Enum):
class PricingStrategy(StrEnum):
"""Dynamic pricing strategy types"""
AGGRESSIVE_GROWTH = "aggressive_growth"
PROFIT_MAXIMIZATION = "profit_maximization"
MARKET_BALANCE = "market_balance"
@@ -24,16 +24,18 @@ class PricingStrategy(str, Enum):
COMPETITOR_BASED = "competitor_based"
class StrategyPriority(str, Enum):
class StrategyPriority(StrEnum):
"""Strategy priority levels"""
LOW = "low"
MEDIUM = "medium"
HIGH = "high"
CRITICAL = "critical"
class RiskTolerance(str, Enum):
class RiskTolerance(StrEnum):
"""Risk tolerance levels for pricing strategies"""
CONSERVATIVE = "conservative"
MODERATE = "moderate"
AGGRESSIVE = "aggressive"
@@ -42,47 +44,47 @@ class RiskTolerance(str, Enum):
@dataclass
class StrategyParameters:
"""Parameters for pricing strategy configuration"""
# Base pricing parameters
base_multiplier: float = 1.0
min_price_margin: float = 0.1 # 10% minimum margin
max_price_margin: float = 2.0 # 200% maximum margin
# Market sensitivity parameters
demand_sensitivity: float = 0.5 # 0-1, how much demand affects price
supply_sensitivity: float = 0.3 # 0-1, how much supply affects price
competition_sensitivity: float = 0.4 # 0-1, how much competition affects price
# Time-based parameters
peak_hour_multiplier: float = 1.2
off_peak_multiplier: float = 0.8
weekend_multiplier: float = 1.1
# Performance parameters
performance_bonus_rate: float = 0.1 # 10% bonus for high performance
performance_penalty_rate: float = 0.05 # 5% penalty for low performance
# Risk management parameters
max_price_change_percent: float = 0.3 # Maximum 30% change per update
volatility_threshold: float = 0.2 # Trigger for circuit breaker
confidence_threshold: float = 0.7 # Minimum confidence for price changes
# Strategy-specific parameters
growth_target_rate: float = 0.15 # 15% growth target for growth strategies
profit_target_margin: float = 0.25 # 25% profit target for profit strategies
market_share_target: float = 0.1 # 10% market share target
# Regional parameters
regional_adjustments: Dict[str, float] = field(default_factory=dict)
regional_adjustments: dict[str, float] = field(default_factory=dict)
# Custom parameters
custom_parameters: Dict[str, Any] = field(default_factory=dict)
custom_parameters: dict[str, Any] = field(default_factory=dict)
@dataclass
class StrategyRule:
"""Individual rule within a pricing strategy"""
rule_id: str
name: str
description: str
@@ -91,41 +93,41 @@ class StrategyRule:
priority: StrategyPriority
enabled: bool = True
created_at: datetime = field(default_factory=datetime.utcnow)
# Rule execution tracking
execution_count: int = 0
last_executed: Optional[datetime] = None
last_executed: datetime | None = None
success_rate: float = 1.0
@dataclass
class PricingStrategyConfig:
"""Complete configuration for a pricing strategy"""
strategy_id: str
name: str
description: str
strategy_type: PricingStrategy
parameters: StrategyParameters
rules: List[StrategyRule] = field(default_factory=list)
rules: list[StrategyRule] = field(default_factory=list)
# Strategy metadata
risk_tolerance: RiskTolerance = RiskTolerance.MODERATE
priority: StrategyPriority = StrategyPriority.MEDIUM
auto_optimize: bool = True
learning_enabled: bool = True
# Strategy constraints
min_price: Optional[float] = None
max_price: Optional[float] = None
resource_types: List[str] = field(default_factory=list)
regions: List[str] = field(default_factory=list)
min_price: float | None = None
max_price: float | None = None
resource_types: list[str] = field(default_factory=list)
regions: list[str] = field(default_factory=list)
# Performance tracking
created_at: datetime = field(default_factory=datetime.utcnow)
updated_at: datetime = field(default_factory=datetime.utcnow)
last_applied: Optional[datetime] = None
last_applied: datetime | None = None
# Strategy effectiveness metrics
total_revenue_impact: float = 0.0
market_share_impact: float = 0.0
@@ -135,11 +137,11 @@ class PricingStrategyConfig:
class StrategyLibrary:
"""Library of predefined pricing strategies"""
@staticmethod
def get_aggressive_growth_strategy() -> PricingStrategyConfig:
"""Get aggressive growth strategy configuration"""
parameters = StrategyParameters(
base_multiplier=0.85,
min_price_margin=0.05, # Lower margins for growth
@@ -153,9 +155,9 @@ class StrategyLibrary:
performance_bonus_rate=0.05,
performance_penalty_rate=0.02,
growth_target_rate=0.25, # 25% growth target
market_share_target=0.15 # 15% market share target
market_share_target=0.15, # 15% market share target
)
rules = [
StrategyRule(
rule_id="growth_competitive_undercut",
@@ -163,7 +165,7 @@ class StrategyLibrary:
description="Undercut competitors by 5% to gain market share",
condition="competitor_price > 0 and current_price > competitor_price * 0.95",
action="set_price = competitor_price * 0.95",
priority=StrategyPriority.HIGH
priority=StrategyPriority.HIGH,
),
StrategyRule(
rule_id="growth_volume_discount",
@@ -171,10 +173,10 @@ class StrategyLibrary:
description="Offer discounts for high-volume customers",
condition="customer_volume > threshold and customer_loyalty < 6_months",
action="apply_discount = 0.1",
priority=StrategyPriority.MEDIUM
)
priority=StrategyPriority.MEDIUM,
),
]
return PricingStrategyConfig(
strategy_id="aggressive_growth_v1",
name="Aggressive Growth Strategy",
@@ -183,13 +185,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.AGGRESSIVE,
priority=StrategyPriority.HIGH
priority=StrategyPriority.HIGH,
)
@staticmethod
def get_profit_maximization_strategy() -> PricingStrategyConfig:
"""Get profit maximization strategy configuration"""
parameters = StrategyParameters(
base_multiplier=1.25,
min_price_margin=0.3, # Higher margins for profit
@@ -203,9 +205,9 @@ class StrategyLibrary:
performance_bonus_rate=0.15,
performance_penalty_rate=0.08,
profit_target_margin=0.35, # 35% profit target
max_price_change_percent=0.2 # More conservative changes
max_price_change_percent=0.2, # More conservative changes
)
rules = [
StrategyRule(
rule_id="profit_demand_premium",
@@ -213,7 +215,7 @@ class StrategyLibrary:
description="Apply premium pricing during high demand periods",
condition="demand_level > 0.8 and competitor_capacity < 0.7",
action="set_price = current_price * 1.3",
priority=StrategyPriority.CRITICAL
priority=StrategyPriority.CRITICAL,
),
StrategyRule(
rule_id="profit_performance_premium",
@@ -221,10 +223,10 @@ class StrategyLibrary:
description="Charge premium for high-performance resources",
condition="performance_score > 0.9 and customer_satisfaction > 0.85",
action="apply_premium = 0.2",
priority=StrategyPriority.HIGH
)
priority=StrategyPriority.HIGH,
),
]
return PricingStrategyConfig(
strategy_id="profit_maximization_v1",
name="Profit Maximization Strategy",
@@ -233,13 +235,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.MODERATE,
priority=StrategyPriority.HIGH
priority=StrategyPriority.HIGH,
)
@staticmethod
def get_market_balance_strategy() -> PricingStrategyConfig:
"""Get market balance strategy configuration"""
parameters = StrategyParameters(
base_multiplier=1.0,
min_price_margin=0.15,
@@ -253,9 +255,9 @@ class StrategyLibrary:
performance_bonus_rate=0.1,
performance_penalty_rate=0.05,
volatility_threshold=0.15, # Lower volatility threshold
confidence_threshold=0.8 # Higher confidence requirement
confidence_threshold=0.8, # Higher confidence requirement
)
rules = [
StrategyRule(
rule_id="balance_market_follow",
@@ -263,7 +265,7 @@ class StrategyLibrary:
description="Follow market trends while maintaining stability",
condition="market_trend == increasing and price_position < market_average",
action="adjust_price = market_average * 0.98",
priority=StrategyPriority.MEDIUM
priority=StrategyPriority.MEDIUM,
),
StrategyRule(
rule_id="balance_stability_maintain",
@@ -271,10 +273,10 @@ class StrategyLibrary:
description="Maintain price stability during volatile periods",
condition="volatility > 0.15 and confidence < 0.7",
action="freeze_price = true",
priority=StrategyPriority.HIGH
)
priority=StrategyPriority.HIGH,
),
]
return PricingStrategyConfig(
strategy_id="market_balance_v1",
name="Market Balance Strategy",
@@ -283,13 +285,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.MODERATE,
priority=StrategyPriority.MEDIUM
priority=StrategyPriority.MEDIUM,
)
@staticmethod
def get_competitive_response_strategy() -> PricingStrategyConfig:
"""Get competitive response strategy configuration"""
parameters = StrategyParameters(
base_multiplier=0.95,
min_price_margin=0.1,
@@ -301,9 +303,9 @@ class StrategyLibrary:
off_peak_multiplier=0.85,
weekend_multiplier=1.05,
performance_bonus_rate=0.08,
performance_penalty_rate=0.03
performance_penalty_rate=0.03,
)
rules = [
StrategyRule(
rule_id="competitive_price_match",
@@ -311,7 +313,7 @@ class StrategyLibrary:
description="Match or beat competitor prices",
condition="competitor_price < current_price * 0.95",
action="set_price = competitor_price * 0.98",
priority=StrategyPriority.CRITICAL
priority=StrategyPriority.CRITICAL,
),
StrategyRule(
rule_id="competitive_promotion_response",
@@ -319,10 +321,10 @@ class StrategyLibrary:
description="Respond to competitor promotions",
condition="competitor_promotion == true and market_share_declining",
action="apply_promotion = competitor_promotion_rate * 1.1",
priority=StrategyPriority.HIGH
)
priority=StrategyPriority.HIGH,
),
]
return PricingStrategyConfig(
strategy_id="competitive_response_v1",
name="Competitive Response Strategy",
@@ -331,13 +333,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.MODERATE,
priority=StrategyPriority.HIGH
priority=StrategyPriority.HIGH,
)
@staticmethod
def get_demand_elasticity_strategy() -> PricingStrategyConfig:
"""Get demand elasticity strategy configuration"""
parameters = StrategyParameters(
base_multiplier=1.0,
min_price_margin=0.12,
@@ -350,9 +352,9 @@ class StrategyLibrary:
weekend_multiplier=1.1,
performance_bonus_rate=0.1,
performance_penalty_rate=0.05,
max_price_change_percent=0.4 # Allow larger changes for elasticity
max_price_change_percent=0.4, # Allow larger changes for elasticity
)
rules = [
StrategyRule(
rule_id="elasticity_demand_capture",
@@ -360,7 +362,7 @@ class StrategyLibrary:
description="Aggressively price to capture demand surges",
condition="demand_growth_rate > 0.2 and supply_constraint == true",
action="set_price = current_price * 1.25",
priority=StrategyPriority.HIGH
priority=StrategyPriority.HIGH,
),
StrategyRule(
rule_id="elasticity_demand_stimulation",
@@ -368,10 +370,10 @@ class StrategyLibrary:
description="Lower prices to stimulate demand during lulls",
condition="demand_level < 0.4 and inventory_turnover < threshold",
action="apply_discount = 0.15",
priority=StrategyPriority.MEDIUM
)
priority=StrategyPriority.MEDIUM,
),
]
return PricingStrategyConfig(
strategy_id="demand_elasticity_v1",
name="Demand Elasticity Strategy",
@@ -380,13 +382,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.AGGRESSIVE,
priority=StrategyPriority.MEDIUM
priority=StrategyPriority.MEDIUM,
)
@staticmethod
def get_penetration_pricing_strategy() -> PricingStrategyConfig:
"""Get penetration pricing strategy configuration"""
parameters = StrategyParameters(
base_multiplier=0.7, # Low initial prices
min_price_margin=0.05,
@@ -398,9 +400,9 @@ class StrategyLibrary:
off_peak_multiplier=0.6,
weekend_multiplier=0.9,
growth_target_rate=0.3, # 30% growth target
market_share_target=0.2 # 20% market share target
market_share_target=0.2, # 20% market share target
)
rules = [
StrategyRule(
rule_id="penetration_market_entry",
@@ -408,7 +410,7 @@ class StrategyLibrary:
description="Very low prices for new market entry",
condition="market_share < 0.05 and time_in_market < 6_months",
action="set_price = cost * 1.1",
priority=StrategyPriority.CRITICAL
priority=StrategyPriority.CRITICAL,
),
StrategyRule(
rule_id="penetration_gradual_increase",
@@ -416,10 +418,10 @@ class StrategyLibrary:
description="Gradually increase prices after market penetration",
condition="market_share > 0.1 and customer_loyalty > 12_months",
action="increase_price = 0.05",
priority=StrategyPriority.MEDIUM
)
priority=StrategyPriority.MEDIUM,
),
]
return PricingStrategyConfig(
strategy_id="penetration_pricing_v1",
name="Penetration Pricing Strategy",
@@ -428,13 +430,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.AGGRESSIVE,
priority=StrategyPriority.HIGH
priority=StrategyPriority.HIGH,
)
@staticmethod
def get_premium_pricing_strategy() -> PricingStrategyConfig:
"""Get premium pricing strategy configuration"""
parameters = StrategyParameters(
base_multiplier=1.8, # High base prices
min_price_margin=0.5,
@@ -447,9 +449,9 @@ class StrategyLibrary:
weekend_multiplier=1.4,
performance_bonus_rate=0.2,
performance_penalty_rate=0.1,
profit_target_margin=0.4 # 40% profit target
profit_target_margin=0.4, # 40% profit target
)
rules = [
StrategyRule(
rule_id="premium_quality_assurance",
@@ -457,7 +459,7 @@ class StrategyLibrary:
description="Maintain premium pricing for quality assurance",
condition="quality_score > 0.95 and brand_recognition > high",
action="maintain_premium = true",
priority=StrategyPriority.CRITICAL
priority=StrategyPriority.CRITICAL,
),
StrategyRule(
rule_id="premium_exclusivity",
@@ -465,10 +467,10 @@ class StrategyLibrary:
description="Premium pricing for exclusive features",
condition="exclusive_features == true and customer_segment == premium",
action="apply_premium = 0.3",
priority=StrategyPriority.HIGH
)
priority=StrategyPriority.HIGH,
),
]
return PricingStrategyConfig(
strategy_id="premium_pricing_v1",
name="Premium Pricing Strategy",
@@ -477,13 +479,13 @@ class StrategyLibrary:
parameters=parameters,
rules=rules,
risk_tolerance=RiskTolerance.CONSERVATIVE,
priority=StrategyPriority.MEDIUM
priority=StrategyPriority.MEDIUM,
)
@staticmethod
def get_all_strategies() -> Dict[PricingStrategy, PricingStrategyConfig]:
def get_all_strategies() -> dict[PricingStrategy, PricingStrategyConfig]:
"""Get all available pricing strategies"""
return {
PricingStrategy.AGGRESSIVE_GROWTH: StrategyLibrary.get_aggressive_growth_strategy(),
PricingStrategy.PROFIT_MAXIMIZATION: StrategyLibrary.get_profit_maximization_strategy(),
@@ -491,88 +493,79 @@ class StrategyLibrary:
PricingStrategy.COMPETITIVE_RESPONSE: StrategyLibrary.get_competitive_response_strategy(),
PricingStrategy.DEMAND_ELASTICITY: StrategyLibrary.get_demand_elasticity_strategy(),
PricingStrategy.PENETRATION_PRICING: StrategyLibrary.get_penetration_pricing_strategy(),
PricingStrategy.PREMIUM_PRICING: StrategyLibrary.get_premium_pricing_strategy()
PricingStrategy.PREMIUM_PRICING: StrategyLibrary.get_premium_pricing_strategy(),
}
class StrategyOptimizer:
"""Optimizes pricing strategies based on performance data"""
def __init__(self):
self.performance_history: Dict[str, List[Dict[str, Any]]] = {}
self.performance_history: dict[str, list[dict[str, Any]]] = {}
self.optimization_rules = self._initialize_optimization_rules()
def optimize_strategy(
self,
strategy_config: PricingStrategyConfig,
performance_data: Dict[str, Any]
self, strategy_config: PricingStrategyConfig, performance_data: dict[str, Any]
) -> PricingStrategyConfig:
"""Optimize strategy parameters based on performance"""
strategy_id = strategy_config.strategy_id
# Store performance data
if strategy_id not in self.performance_history:
self.performance_history[strategy_id] = []
self.performance_history[strategy_id].append({
"timestamp": datetime.utcnow(),
"performance": performance_data
})
self.performance_history[strategy_id].append({"timestamp": datetime.utcnow(), "performance": performance_data})
# Apply optimization rules
optimized_config = self._apply_optimization_rules(strategy_config, performance_data)
# Update strategy effectiveness score
optimized_config.strategy_effectiveness_score = self._calculate_effectiveness_score(
performance_data
)
optimized_config.strategy_effectiveness_score = self._calculate_effectiveness_score(performance_data)
return optimized_config
def _initialize_optimization_rules(self) -> List[Dict[str, Any]]:
def _initialize_optimization_rules(self) -> list[dict[str, Any]]:
"""Initialize optimization rules"""
return [
{
"name": "Revenue Optimization",
"condition": "revenue_growth < target and price_elasticity > 0.5",
"action": "decrease_base_multiplier",
"adjustment": -0.05
"adjustment": -0.05,
},
{
"name": "Margin Protection",
"condition": "profit_margin < minimum and demand_inelastic",
"action": "increase_base_multiplier",
"adjustment": 0.03
"adjustment": 0.03,
},
{
"name": "Market Share Growth",
"condition": "market_share_declining and competitive_pressure_high",
"action": "increase_competition_sensitivity",
"adjustment": 0.1
"adjustment": 0.1,
},
{
"name": "Volatility Reduction",
"condition": "price_volatility > threshold and customer_complaints_high",
"action": "decrease_max_price_change",
"adjustment": -0.1
"adjustment": -0.1,
},
{
"name": "Demand Capture",
"condition": "demand_surge_detected and capacity_available",
"action": "increase_demand_sensitivity",
"adjustment": 0.15
}
"adjustment": 0.15,
},
]
def _apply_optimization_rules(
self,
strategy_config: PricingStrategyConfig,
performance_data: Dict[str, Any]
self, strategy_config: PricingStrategyConfig, performance_data: dict[str, Any]
) -> PricingStrategyConfig:
"""Apply optimization rules to strategy configuration"""
# Create a copy to avoid modifying the original
optimized_config = PricingStrategyConfig(
strategy_id=strategy_config.strategy_id,
@@ -598,7 +591,7 @@ class StrategyOptimizer:
profit_target_margin=strategy_config.parameters.profit_target_margin,
market_share_target=strategy_config.parameters.market_share_target,
regional_adjustments=strategy_config.parameters.regional_adjustments.copy(),
custom_parameters=strategy_config.parameters.custom_parameters.copy()
custom_parameters=strategy_config.parameters.custom_parameters.copy(),
),
rules=strategy_config.rules.copy(),
risk_tolerance=strategy_config.risk_tolerance,
@@ -608,24 +601,24 @@ class StrategyOptimizer:
min_price=strategy_config.min_price,
max_price=strategy_config.max_price,
resource_types=strategy_config.resource_types.copy(),
regions=strategy_config.regions.copy()
regions=strategy_config.regions.copy(),
)
# Apply each optimization rule
for rule in self.optimization_rules:
if self._evaluate_rule_condition(rule["condition"], performance_data):
self._apply_rule_action(optimized_config, rule["action"], rule["adjustment"])
return optimized_config
def _evaluate_rule_condition(self, condition: str, performance_data: Dict[str, Any]) -> bool:
def _evaluate_rule_condition(self, condition: str, performance_data: dict[str, Any]) -> bool:
"""Evaluate optimization rule condition"""
# Simple condition evaluation (in production, use a proper expression evaluator)
try:
# Replace variables with actual values
condition_eval = condition
# Common performance metrics
metrics = {
"revenue_growth": performance_data.get("revenue_growth", 0),
@@ -636,26 +629,26 @@ class StrategyOptimizer:
"price_volatility": performance_data.get("price_volatility", 0.1),
"customer_complaints_high": performance_data.get("customer_complaints_high", False),
"demand_surge_detected": performance_data.get("demand_surge_detected", False),
"capacity_available": performance_data.get("capacity_available", True)
"capacity_available": performance_data.get("capacity_available", True),
}
# Simple condition parsing
for key, value in metrics.items():
condition_eval = condition_eval.replace(key, str(value))
# Evaluate simple conditions
if "and" in condition_eval:
parts = condition_eval.split(" and ")
return all(self._evaluate_simple_condition(part.strip()) for part in parts)
else:
return self._evaluate_simple_condition(condition_eval.strip())
except Exception as e:
except Exception:
return False
def _evaluate_simple_condition(self, condition: str) -> bool:
"""Evaluate a simple condition"""
try:
# Handle common comparison operators
if "<" in condition:
@@ -673,13 +666,13 @@ class StrategyOptimizer:
return False
else:
return bool(condition)
except Exception:
return False
def _apply_rule_action(self, config: PricingStrategyConfig, action: str, adjustment: float):
"""Apply optimization rule action"""
if action == "decrease_base_multiplier":
config.parameters.base_multiplier = max(0.5, config.parameters.base_multiplier + adjustment)
elif action == "increase_base_multiplier":
@@ -690,22 +683,22 @@ class StrategyOptimizer:
config.parameters.max_price_change_percent = max(0.1, config.parameters.max_price_change_percent + adjustment)
elif action == "increase_demand_sensitivity":
config.parameters.demand_sensitivity = min(1.0, config.parameters.demand_sensitivity + adjustment)
def _calculate_effectiveness_score(self, performance_data: Dict[str, Any]) -> float:
def _calculate_effectiveness_score(self, performance_data: dict[str, Any]) -> float:
"""Calculate overall strategy effectiveness score"""
# Weight different performance metrics
weights = {
"revenue_growth": 0.3,
"profit_margin": 0.25,
"market_share": 0.2,
"customer_satisfaction": 0.15,
"price_stability": 0.1
"price_stability": 0.1,
}
score = 0.0
total_weight = 0.0
for metric, weight in weights.items():
if metric in performance_data:
value = performance_data[metric]
@@ -714,8 +707,8 @@ class StrategyOptimizer:
normalized_value = min(1.0, max(0.0, value))
else: # price_stability (lower is better, so invert)
normalized_value = min(1.0, max(0.0, 1.0 - value))
score += normalized_value * weight
total_weight += weight
return score / total_weight if total_weight > 0 else 0.5

145
apps/coordinator-api/src/app/domain/reputation.py
View File

@@ -3,17 +3,17 @@ Agent Reputation and Trust System Domain Models
Implements SQLModel definitions for agent reputation, trust scores, and economic metrics
"""
from datetime import datetime, timedelta
from typing import Optional, Dict, List, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Float, Integer, Text
from sqlmodel import JSON, Column, Field, SQLModel
class ReputationLevel(str, Enum):
class ReputationLevel(StrEnum):
"""Agent reputation level enumeration"""
BEGINNER = "beginner"
INTERMEDIATE = "intermediate"
ADVANCED = "advanced"
@@ -21,8 +21,9 @@ class ReputationLevel(str, Enum):
MASTER = "master"
class TrustScoreCategory(str, Enum):
class TrustScoreCategory(StrEnum):
"""Trust score calculation categories"""
PERFORMANCE = "performance"
RELIABILITY = "reliability"
COMMUNITY = "community"
@@ -32,224 +33,224 @@ class TrustScoreCategory(str, Enum):
class AgentReputation(SQLModel, table=True):
"""Agent reputation profile and metrics"""
__tablename__ = "agent_reputation"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"rep_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="ai_agent_workflows.id")
# Core reputation metrics
trust_score: float = Field(default=500.0, ge=0, le=1000) # 0-1000 scale
reputation_level: ReputationLevel = Field(default=ReputationLevel.BEGINNER)
performance_rating: float = Field(default=3.0, ge=1.0, le=5.0) # 1-5 stars
reliability_score: float = Field(default=50.0, ge=0, le=100.0) # 0-100%
community_rating: float = Field(default=3.0, ge=1.0, le=5.0) # 1-5 stars
# Economic metrics
total_earnings: float = Field(default=0.0) # Total AITBC earned
transaction_count: int = Field(default=0) # Total transactions
success_rate: float = Field(default=0.0, ge=0, le=100.0) # Success percentage
dispute_count: int = Field(default=0) # Number of disputes
dispute_won_count: int = Field(default=0) # Disputes won
# Activity metrics
jobs_completed: int = Field(default=0)
jobs_failed: int = Field(default=0)
average_response_time: float = Field(default=0.0) # milliseconds
uptime_percentage: float = Field(default=0.0, ge=0, le=100.0)
# Geographic and service info
geographic_region: str = Field(default="", max_length=50)
service_categories: List[str] = Field(default=[], sa_column=Column(JSON))
specialization_tags: List[str] = Field(default=[], sa_column=Column(JSON))
service_categories: list[str] = Field(default=[], sa_column=Column(JSON))
specialization_tags: list[str] = Field(default=[], sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_activity: datetime = Field(default_factory=datetime.utcnow)
# Additional metadata
reputation_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
achievements: List[str] = Field(default=[], sa_column=Column(JSON))
certifications: List[str] = Field(default=[], sa_column=Column(JSON))
reputation_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
achievements: list[str] = Field(default=[], sa_column=Column(JSON))
certifications: list[str] = Field(default=[], sa_column=Column(JSON))
class TrustScoreCalculation(SQLModel, table=True):
"""Trust score calculation records and factors"""
__tablename__ = "trust_score_calculations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"trust_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reputation.id")
# Calculation details
category: TrustScoreCategory
base_score: float = Field(ge=0, le=1000)
weight_factor: float = Field(default=1.0, ge=0, le=10)
adjusted_score: float = Field(ge=0, le=1000)
# Contributing factors
performance_factor: float = Field(default=1.0)
reliability_factor: float = Field(default=1.0)
community_factor: float = Field(default=1.0)
security_factor: float = Field(default=1.0)
economic_factor: float = Field(default=1.0)
# Calculation metadata
calculation_method: str = Field(default="weighted_average")
confidence_level: float = Field(default=0.8, ge=0, le=1.0)
# Timestamps
calculated_at: datetime = Field(default_factory=datetime.utcnow)
effective_period: int = Field(default=86400) # seconds
# Additional data
calculation_details: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
calculation_details: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class ReputationEvent(SQLModel, table=True):
"""Reputation-changing events and transactions"""
__tablename__ = "reputation_events"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"event_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reputation.id")
# Event details
event_type: str = Field(max_length=50) # "job_completed", "dispute_resolved", etc.
event_subtype: str = Field(default="", max_length=50)
impact_score: float = Field(ge=-100, le=100) # Positive or negative impact
# Scoring details
trust_score_before: float = Field(ge=0, le=1000)
trust_score_after: float = Field(ge=0, le=1000)
reputation_level_before: Optional[ReputationLevel] = None
reputation_level_after: Optional[ReputationLevel] = None
reputation_level_before: ReputationLevel | None = None
reputation_level_after: ReputationLevel | None = None
# Event context
related_transaction_id: Optional[str] = None
related_job_id: Optional[str] = None
related_dispute_id: Optional[str] = None
related_transaction_id: str | None = None
related_job_id: str | None = None
related_dispute_id: str | None = None
# Event metadata
event_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
event_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
verification_status: str = Field(default="pending") # pending, verified, rejected
# Timestamps
occurred_at: datetime = Field(default_factory=datetime.utcnow)
processed_at: Optional[datetime] = None
expires_at: Optional[datetime] = None
processed_at: datetime | None = None
expires_at: datetime | None = None
class AgentEconomicProfile(SQLModel, table=True):
"""Detailed economic profile for agents"""
__tablename__ = "agent_economic_profiles"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"econ_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reputation.id")
# Earnings breakdown
daily_earnings: float = Field(default=0.0)
weekly_earnings: float = Field(default=0.0)
monthly_earnings: float = Field(default=0.0)
yearly_earnings: float = Field(default=0.0)
# Performance metrics
average_job_value: float = Field(default=0.0)
peak_hourly_rate: float = Field(default=0.0)
utilization_rate: float = Field(default=0.0, ge=0, le=100.0)
# Market position
market_share: float = Field(default=0.0, ge=0, le=100.0)
competitive_ranking: int = Field(default=0)
price_tier: str = Field(default="standard") # budget, standard, premium
# Risk metrics
default_risk_score: float = Field(default=0.0, ge=0, le=100.0)
volatility_score: float = Field(default=0.0, ge=0, le=100.0)
liquidity_score: float = Field(default=0.0, ge=0, le=100.0)
# Timestamps
profile_date: datetime = Field(default_factory=datetime.utcnow)
last_updated: datetime = Field(default_factory=datetime.utcnow)
# Historical data
earnings_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
performance_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
earnings_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
performance_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class CommunityFeedback(SQLModel, table=True):
"""Community feedback and ratings for agents"""
__tablename__ = "community_feedback"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"feedback_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reputation.id")
# Feedback details
reviewer_id: str = Field(index=True)
reviewer_type: str = Field(default="client") # client, provider, peer
# Ratings
overall_rating: float = Field(ge=1.0, le=5.0)
performance_rating: float = Field(ge=1.0, le=5.0)
communication_rating: float = Field(ge=1.0, le=5.0)
reliability_rating: float = Field(ge=1.0, le=5.0)
value_rating: float = Field(ge=1.0, le=5.0)
# Feedback content
feedback_text: str = Field(default="", max_length=1000)
feedback_tags: List[str] = Field(default=[], sa_column=Column(JSON))
feedback_tags: list[str] = Field(default=[], sa_column=Column(JSON))
# Verification
verified_transaction: bool = Field(default=False)
verification_weight: float = Field(default=1.0, ge=0.1, le=10.0)
# Moderation
moderation_status: str = Field(default="approved") # approved, pending, rejected
moderator_notes: str = Field(default="", max_length=500)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
helpful_votes: int = Field(default=0)
# Additional metadata
feedback_context: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
feedback_context: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class ReputationLevelThreshold(SQLModel, table=True):
"""Configuration for reputation level thresholds"""
__tablename__ = "reputation_level_thresholds"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"threshold_{uuid4().hex[:8]}", primary_key=True)
level: ReputationLevel
# Threshold requirements
min_trust_score: float = Field(ge=0, le=1000)
min_performance_rating: float = Field(ge=1.0, le=5.0)
min_reliability_score: float = Field(ge=0, le=100.0)
min_transactions: int = Field(default=0)
min_success_rate: float = Field(ge=0, le=100.0)
# Benefits and restrictions
max_concurrent_jobs: int = Field(default=1)
priority_boost: float = Field(default=1.0)
fee_discount: float = Field(default=0.0, ge=0, le=100.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
is_active: bool = Field(default=True)
# Additional configuration
level_requirements: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
level_benefits: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
level_requirements: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
level_benefits: dict[str, Any] = Field(default={}, sa_column=Column(JSON))

188
apps/coordinator-api/src/app/domain/rewards.py
View File

@@ -3,17 +3,17 @@ Agent Reward System Domain Models
Implements SQLModel definitions for performance-based rewards, incentives, and distributions
"""
from datetime import datetime, timedelta
from typing import Optional, Dict, List, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Float, Integer, Text
from sqlmodel import JSON, Column, Field, SQLModel
class RewardTier(str, Enum):
class RewardTier(StrEnum):
"""Reward tier enumeration"""
BRONZE = "bronze"
SILVER = "silver"
GOLD = "gold"
@@ -21,8 +21,9 @@ class RewardTier(str, Enum):
DIAMOND = "diamond"
class RewardType(str, Enum):
class RewardType(StrEnum):
"""Reward type enumeration"""
PERFORMANCE_BONUS = "performance_bonus"
LOYALTY_BONUS = "loyalty_bonus"
REFERRAL_BONUS = "referral_bonus"
@@ -31,8 +32,9 @@ class RewardType(str, Enum):
SPECIAL_BONUS = "special_bonus"
class RewardStatus(str, Enum):
class RewardStatus(StrEnum):
"""Reward status enumeration"""
PENDING = "pending"
APPROVED = "approved"
DISTRIBUTED = "distributed"
@@ -42,261 +44,261 @@ class RewardStatus(str, Enum):
class RewardTierConfig(SQLModel, table=True):
"""Reward tier configuration and thresholds"""
__tablename__ = "reward_tier_configs"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"tier_{uuid4().hex[:8]}", primary_key=True)
tier: RewardTier
# Threshold requirements
min_trust_score: float = Field(ge=0, le=1000)
min_performance_rating: float = Field(ge=1.0, le=5.0)
min_monthly_earnings: float = Field(ge=0)
min_transaction_count: int = Field(ge=0)
min_success_rate: float = Field(ge=0, le=100.0)
# Reward multipliers and benefits
base_multiplier: float = Field(default=1.0, ge=1.0)
performance_bonus_multiplier: float = Field(default=1.0, ge=1.0)
loyalty_bonus_multiplier: float = Field(default=1.0, ge=1.0)
referral_bonus_multiplier: float = Field(default=1.0, ge=1.0)
# Tier benefits
max_concurrent_jobs: int = Field(default=1)
priority_boost: float = Field(default=1.0)
fee_discount: float = Field(default=0.0, ge=0, le=100.0)
support_level: str = Field(default="basic")
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
is_active: bool = Field(default=True)
# Additional configuration
tier_requirements: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
tier_benefits: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
tier_requirements: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
tier_benefits: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class AgentRewardProfile(SQLModel, table=True):
"""Agent reward profile and earnings tracking"""
__tablename__ = "agent_reward_profiles"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"reward_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reputation.id")
# Current tier and status
current_tier: RewardTier = Field(default=RewardTier.BRONZE)
tier_progress: float = Field(default=0.0, ge=0, le=100.0) # Progress to next tier
# Earnings tracking
base_earnings: float = Field(default=0.0)
bonus_earnings: float = Field(default=0.0)
total_earnings: float = Field(default=0.0)
lifetime_earnings: float = Field(default=0.0)
# Performance metrics for rewards
performance_score: float = Field(default=0.0)
loyalty_score: float = Field(default=0.0)
referral_count: int = Field(default=0)
community_contributions: int = Field(default=0)
# Reward history
rewards_distributed: int = Field(default=0)
last_reward_date: Optional[datetime] = None
last_reward_date: datetime | None = None
current_streak: int = Field(default=0) # Consecutive reward periods
longest_streak: int = Field(default=0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_activity: datetime = Field(default_factory=datetime.utcnow)
# Additional metadata
reward_preferences: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
achievement_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
reward_preferences: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
achievement_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class RewardCalculation(SQLModel, table=True):
"""Reward calculation records and factors"""
__tablename__ = "reward_calculations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"calc_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reward_profiles.id")
# Calculation details
reward_type: RewardType
base_amount: float = Field(ge=0)
tier_multiplier: float = Field(default=1.0, ge=1.0)
# Bonus factors
performance_bonus: float = Field(default=0.0)
loyalty_bonus: float = Field(default=0.0)
referral_bonus: float = Field(default=0.0)
community_bonus: float = Field(default=0.0)
special_bonus: float = Field(default=0.0)
# Final calculation
total_reward: float = Field(ge=0)
effective_multiplier: float = Field(default=1.0, ge=1.0)
# Calculation metadata
calculation_period: str = Field(default="daily") # daily, weekly, monthly
reference_date: datetime = Field(default_factory=datetime.utcnow)
trust_score_at_calculation: float = Field(ge=0, le=1000)
performance_metrics: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Timestamps
calculated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
# Additional data
calculation_details: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
calculation_details: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class RewardDistribution(SQLModel, table=True):
"""Reward distribution records and transactions"""
__tablename__ = "reward_distributions"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"dist_{uuid4().hex[:8]}", primary_key=True)
calculation_id: str = Field(index=True, foreign_key="reward_calculations.id")
agent_id: str = Field(index=True, foreign_key="agent_reward_profiles.id")
# Distribution details
reward_amount: float = Field(ge=0)
reward_type: RewardType
distribution_method: str = Field(default="automatic") # automatic, manual, batch
# Transaction details
transaction_id: Optional[str] = None
transaction_hash: Optional[str] = None
transaction_id: str | None = None
transaction_hash: str | None = None
transaction_status: str = Field(default="pending")
# Status tracking
status: RewardStatus = Field(default=RewardStatus.PENDING)
processed_at: Optional[datetime] = None
confirmed_at: Optional[datetime] = None
processed_at: datetime | None = None
confirmed_at: datetime | None = None
# Distribution metadata
batch_id: Optional[str] = None
batch_id: str | None = None
priority: int = Field(default=5, ge=1, le=10) # 1 = highest priority
retry_count: int = Field(default=0)
error_message: Optional[str] = None
error_message: str | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
scheduled_at: Optional[datetime] = None
scheduled_at: datetime | None = None
# Additional data
distribution_details: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
distribution_details: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class RewardEvent(SQLModel, table=True):
"""Reward-related events and triggers"""
__tablename__ = "reward_events"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"event_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reward_profiles.id")
# Event details
event_type: str = Field(max_length=50) # "tier_upgrade", "milestone_reached", etc.
event_subtype: str = Field(default="", max_length=50)
trigger_source: str = Field(max_length=50) # "system", "manual", "automatic"
# Event impact
reward_impact: float = Field(ge=0) # Total reward amount from this event
tier_impact: Optional[RewardTier] = None
tier_impact: RewardTier | None = None
# Event context
related_transaction_id: Optional[str] = None
related_calculation_id: Optional[str] = None
related_distribution_id: Optional[str] = None
related_transaction_id: str | None = None
related_calculation_id: str | None = None
related_distribution_id: str | None = None
# Event metadata
event_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
event_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
verification_status: str = Field(default="pending") # pending, verified, rejected
# Timestamps
occurred_at: datetime = Field(default_factory=datetime.utcnow)
processed_at: Optional[datetime] = None
expires_at: Optional[datetime] = None
processed_at: datetime | None = None
expires_at: datetime | None = None
# Additional metadata
event_context: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
event_context: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class RewardMilestone(SQLModel, table=True):
"""Reward milestones and achievements"""
__tablename__ = "reward_milestones"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"milestone_{uuid4().hex[:8]}", primary_key=True)
agent_id: str = Field(index=True, foreign_key="agent_reward_profiles.id")
# Milestone details
milestone_type: str = Field(max_length=50) # "earnings", "jobs", "reputation", etc.
milestone_name: str = Field(max_length=100)
milestone_description: str = Field(default="", max_length=500)
# Threshold and progress
target_value: float = Field(ge=0)
current_value: float = Field(default=0.0, ge=0)
progress_percentage: float = Field(default=0.0, ge=0, le=100.0)
# Rewards
reward_amount: float = Field(default=0.0, ge=0)
reward_type: RewardType = Field(default=RewardType.MILESTONE_BONUS)
# Status
is_completed: bool = Field(default=False)
is_claimed: bool = Field(default=False)
completed_at: Optional[datetime] = None
claimed_at: Optional[datetime] = None
completed_at: datetime | None = None
claimed_at: datetime | None = None
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
# Additional data
milestone_config: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
milestone_config: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class RewardAnalytics(SQLModel, table=True):
"""Reward system analytics and metrics"""
__tablename__ = "reward_analytics"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"analytics_{uuid4().hex[:8]}", primary_key=True)
# Analytics period
period_type: str = Field(default="daily") # daily, weekly, monthly
period_start: datetime
period_end: datetime
# Aggregate metrics
total_rewards_distributed: float = Field(default=0.0)
total_agents_rewarded: int = Field(default=0)
average_reward_per_agent: float = Field(default=0.0)
# Tier distribution
bronze_rewards: float = Field(default=0.0)
silver_rewards: float = Field(default=0.0)
gold_rewards: float = Field(default=0.0)
platinum_rewards: float = Field(default=0.0)
diamond_rewards: float = Field(default=0.0)
# Reward type distribution
performance_rewards: float = Field(default=0.0)
loyalty_rewards: float = Field(default=0.0)
@@ -304,16 +306,16 @@ class RewardAnalytics(SQLModel, table=True):
milestone_rewards: float = Field(default=0.0)
community_rewards: float = Field(default=0.0)
special_rewards: float = Field(default=0.0)
# Performance metrics
calculation_count: int = Field(default=0)
distribution_count: int = Field(default=0)
success_rate: float = Field(default=0.0, ge=0, le=100.0)
average_processing_time: float = Field(default=0.0) # milliseconds
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional analytics data
analytics_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
analytics_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))

313
apps/coordinator-api/src/app/domain/trading.py
View File

@@ -3,17 +3,17 @@ Agent-to-Agent Trading Protocol Domain Models
Implements SQLModel definitions for P2P trading, matching, negotiation, and settlement
"""
from datetime import datetime, timedelta
from typing import Optional, Dict, List, Any
from datetime import datetime
from enum import StrEnum
from typing import Any
from uuid import uuid4
from enum import Enum
from sqlmodel import SQLModel, Field, Column, JSON
from sqlalchemy import DateTime, Float, Integer, Text
from sqlmodel import JSON, Column, Field, SQLModel
class TradeStatus(str, Enum):
class TradeStatus(StrEnum):
"""Trade status enumeration"""
OPEN = "open"
MATCHING = "matching"
NEGOTIATING = "negotiating"
@@ -24,8 +24,9 @@ class TradeStatus(str, Enum):
FAILED = "failed"
class TradeType(str, Enum):
class TradeType(StrEnum):
"""Trade type enumeration"""
AI_POWER = "ai_power"
COMPUTE_RESOURCES = "compute_resources"
DATA_SERVICES = "data_services"
@@ -34,8 +35,9 @@ class TradeType(str, Enum):
TRAINING_TASKS = "training_tasks"
class NegotiationStatus(str, Enum):
class NegotiationStatus(StrEnum):
"""Negotiation status enumeration"""
PENDING = "pending"
ACTIVE = "active"
ACCEPTED = "accepted"
@@ -44,8 +46,9 @@ class NegotiationStatus(str, Enum):
EXPIRED = "expired"
class SettlementType(str, Enum):
class SettlementType(StrEnum):
"""Settlement type enumeration"""
IMMEDIATE = "immediate"
ESCROW = "escrow"
MILESTONE = "milestone"
@@ -54,373 +57,373 @@ class SettlementType(str, Enum):
class TradeRequest(SQLModel, table=True):
"""P2P trade request from buyer agent"""
__tablename__ = "trade_requests"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"req_{uuid4().hex[:8]}", primary_key=True)
request_id: str = Field(unique=True, index=True)
# Request details
buyer_agent_id: str = Field(index=True)
trade_type: TradeType
title: str = Field(max_length=200)
description: str = Field(default="", max_length=1000)
# Requirements and specifications
requirements: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
specifications: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
constraints: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
requirements: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
specifications: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
constraints: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Pricing and terms
budget_range: Dict[str, float] = Field(default={}, sa_column=Column(JSON)) # min, max
preferred_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
budget_range: dict[str, float] = Field(default={}, sa_column=Column(JSON)) # min, max
preferred_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
negotiation_flexible: bool = Field(default=True)
# Timing and duration
start_time: Optional[datetime] = None
end_time: Optional[datetime] = None
duration_hours: Optional[int] = None
start_time: datetime | None = None
end_time: datetime | None = None
duration_hours: int | None = None
urgency_level: str = Field(default="normal") # low, normal, high, urgent
# Geographic and service constraints
preferred_regions: List[str] = Field(default=[], sa_column=Column(JSON))
excluded_regions: List[str] = Field(default=[], sa_column=Column(JSON))
preferred_regions: list[str] = Field(default=[], sa_column=Column(JSON))
excluded_regions: list[str] = Field(default=[], sa_column=Column(JSON))
service_level_required: str = Field(default="standard") # basic, standard, premium
# Status and metadata
status: TradeStatus = Field(default=TradeStatus.OPEN)
priority: int = Field(default=5, ge=1, le=10) # 1 = highest priority
# Matching and negotiation
match_count: int = Field(default=0)
negotiation_count: int = Field(default=0)
best_match_score: float = Field(default=0.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
expires_at: datetime | None = None
last_activity: datetime = Field(default_factory=datetime.utcnow)
# Additional metadata
tags: List[str] = Field(default=[], sa_column=Column(JSON))
trading_meta_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
tags: list[str] = Field(default=[], sa_column=Column(JSON))
trading_meta_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class TradeMatch(SQLModel, table=True):
"""Trade match between buyer request and seller offer"""
__tablename__ = "trade_matches"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"match_{uuid4().hex[:8]}", primary_key=True)
match_id: str = Field(unique=True, index=True)
# Match participants
request_id: str = Field(index=True, foreign_key="trade_requests.request_id")
buyer_agent_id: str = Field(index=True)
seller_agent_id: str = Field(index=True)
# Matching details
match_score: float = Field(ge=0, le=100) # 0-100 compatibility score
confidence_level: float = Field(ge=0, le=1) # 0-1 confidence in match
# Compatibility factors
price_compatibility: float = Field(ge=0, le=100)
timing_compatibility: float = Field(ge=0, le=100)
specification_compatibility: float = Field(ge=0, le=100)
reputation_compatibility: float = Field(ge=0, le=100)
geographic_compatibility: float = Field(ge=0, le=100)
# Seller offer details
seller_offer: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
proposed_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
seller_offer: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
proposed_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Status and interaction
status: TradeStatus = Field(default=TradeStatus.MATCHING)
buyer_response: Optional[str] = None # interested, not_interested, negotiating
seller_response: Optional[str] = None # accepted, rejected, countered
buyer_response: str | None = None # interested, not_interested, negotiating
seller_response: str | None = None # accepted, rejected, countered
# Negotiation initiation
negotiation_initiated: bool = Field(default=False)
negotiation_initiator: Optional[str] = None # buyer, seller
initial_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
negotiation_initiator: str | None = None # buyer, seller
initial_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: Optional[datetime] = None
last_interaction: Optional[datetime] = None
expires_at: datetime | None = None
last_interaction: datetime | None = None
# Additional data
match_factors: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
interaction_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
match_factors: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
interaction_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class TradeNegotiation(SQLModel, table=True):
"""Negotiation process between buyer and seller"""
__tablename__ = "trade_negotiations"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"neg_{uuid4().hex[:8]}", primary_key=True)
negotiation_id: str = Field(unique=True, index=True)
# Negotiation participants
match_id: str = Field(index=True, foreign_key="trade_matches.match_id")
buyer_agent_id: str = Field(index=True)
seller_agent_id: str = Field(index=True)
# Negotiation details
status: NegotiationStatus = Field(default=NegotiationStatus.PENDING)
negotiation_round: int = Field(default=1)
max_rounds: int = Field(default=5)
# Terms and conditions
current_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
initial_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
final_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
current_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
initial_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
final_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Negotiation parameters
price_range: Dict[str, float] = Field(default={}, sa_column=Column(JSON))
service_level_agreements: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
delivery_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
payment_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
price_range: dict[str, float] = Field(default={}, sa_column=Column(JSON))
service_level_agreements: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
delivery_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
payment_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Negotiation metrics
concession_count: int = Field(default=0)
counter_offer_count: int = Field(default=0)
agreement_score: float = Field(default=0.0, ge=0, le=100)
# AI negotiation assistance
ai_assisted: bool = Field(default=True)
negotiation_strategy: str = Field(default="balanced") # aggressive, balanced, cooperative
auto_accept_threshold: float = Field(default=85.0, ge=0, le=100)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
started_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
expires_at: Optional[datetime] = None
last_offer_at: Optional[datetime] = None
started_at: datetime | None = None
completed_at: datetime | None = None
expires_at: datetime | None = None
last_offer_at: datetime | None = None
# Additional data
negotiation_history: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
ai_recommendations: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
negotiation_history: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
ai_recommendations: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class TradeAgreement(SQLModel, table=True):
"""Final trade agreement between buyer and seller"""
__tablename__ = "trade_agreements"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"agree_{uuid4().hex[:8]}", primary_key=True)
agreement_id: str = Field(unique=True, index=True)
# Agreement participants
negotiation_id: str = Field(index=True, foreign_key="trade_negotiations.negotiation_id")
buyer_agent_id: str = Field(index=True)
seller_agent_id: str = Field(index=True)
# Agreement details
trade_type: TradeType
title: str = Field(max_length=200)
description: str = Field(default="", max_length=1000)
# Final terms and conditions
agreed_terms: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
specifications: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
service_level_agreement: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
agreed_terms: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
specifications: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
service_level_agreement: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Pricing and payment
total_price: float = Field(ge=0)
currency: str = Field(default="AITBC")
payment_schedule: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
payment_schedule: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
settlement_type: SettlementType
# Delivery and performance
delivery_timeline: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
quality_standards: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
delivery_timeline: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
quality_standards: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Legal and compliance
terms_and_conditions: str = Field(default="", max_length=5000)
compliance_requirements: List[str] = Field(default=[], sa_column=Column(JSON))
dispute_resolution: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
compliance_requirements: list[str] = Field(default=[], sa_column=Column(JSON))
dispute_resolution: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Status and execution
status: TradeStatus = Field(default=TradeStatus.AGREED)
execution_status: str = Field(default="pending") # pending, active, completed, failed
completion_percentage: float = Field(default=0.0, ge=0, le=100)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
signed_at: datetime = Field(default_factory=datetime.utcnow)
starts_at: Optional[datetime] = None
ends_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
starts_at: datetime | None = None
ends_at: datetime | None = None
completed_at: datetime | None = None
# Additional data
agreement_document: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
attachments: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
agreement_document: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
attachments: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class TradeSettlement(SQLModel, table=True):
"""Trade settlement and payment processing"""
__tablename__ = "trade_settlements"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"settle_{uuid4().hex[:8]}", primary_key=True)
settlement_id: str = Field(unique=True, index=True)
# Settlement reference
agreement_id: str = Field(index=True, foreign_key="trade_agreements.agreement_id")
buyer_agent_id: str = Field(index=True)
seller_agent_id: str = Field(index=True)
# Settlement details
settlement_type: SettlementType
total_amount: float = Field(ge=0)
currency: str = Field(default="AITBC")
# Payment processing
payment_status: str = Field(default="pending") # pending, processing, completed, failed
transaction_id: Optional[str] = None
transaction_hash: Optional[str] = None
block_number: Optional[int] = None
transaction_id: str | None = None
transaction_hash: str | None = None
block_number: int | None = None
# Escrow details (if applicable)
escrow_enabled: bool = Field(default=False)
escrow_address: Optional[str] = None
escrow_release_conditions: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
escrow_address: str | None = None
escrow_release_conditions: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Milestone payments (if applicable)
milestone_payments: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
completed_milestones: List[str] = Field(default=[], sa_column=Column(JSON))
milestone_payments: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
completed_milestones: list[str] = Field(default=[], sa_column=Column(JSON))
# Fees and deductions
platform_fee: float = Field(default=0.0)
processing_fee: float = Field(default=0.0)
gas_fee: float = Field(default=0.0)
net_amount_seller: float = Field(ge=0)
# Status and timestamps
status: TradeStatus = Field(default=TradeStatus.SETTLING)
initiated_at: datetime = Field(default_factory=datetime.utcnow)
processed_at: Optional[datetime] = None
completed_at: Optional[datetime] = None
refunded_at: Optional[datetime] = None
processed_at: datetime | None = None
completed_at: datetime | None = None
refunded_at: datetime | None = None
# Dispute and resolution
dispute_raised: bool = Field(default=False)
dispute_details: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
resolution_details: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
dispute_details: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
resolution_details: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
# Additional data
settlement_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
audit_trail: List[Dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
settlement_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
audit_trail: list[dict[str, Any]] = Field(default=[], sa_column=Column(JSON))
class TradeFeedback(SQLModel, table=True):
"""Trade feedback and rating system"""
__tablename__ = "trade_feedback"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"feedback_{uuid4().hex[:8]}", primary_key=True)
# Feedback reference
agreement_id: str = Field(index=True, foreign_key="trade_agreements.agreement_id")
reviewer_agent_id: str = Field(index=True)
reviewed_agent_id: str = Field(index=True)
reviewer_role: str = Field(default="buyer") # buyer, seller
# Ratings
overall_rating: float = Field(ge=1.0, le=5.0)
communication_rating: float = Field(ge=1.0, le=5.0)
performance_rating: float = Field(ge=1.0, le=5.0)
timeliness_rating: float = Field(ge=1.0, le=5.0)
value_rating: float = Field(ge=1.0, le=5.0)
# Feedback content
feedback_text: str = Field(default="", max_length=1000)
feedback_tags: List[str] = Field(default=[], sa_column=Column(JSON))
feedback_tags: list[str] = Field(default=[], sa_column=Column(JSON))
# Trade specifics
trade_category: str = Field(default="general")
trade_complexity: str = Field(default="medium") # simple, medium, complex
trade_duration: Optional[int] = None # in hours
trade_duration: int | None = None # in hours
# Verification and moderation
verified_trade: bool = Field(default=True)
moderation_status: str = Field(default="approved") # approved, pending, rejected
moderator_notes: str = Field(default="", max_length=500)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
trade_completed_at: datetime
# Additional data
feedback_context: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
feedback_context: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
performance_metrics: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
class TradingAnalytics(SQLModel, table=True):
"""P2P trading system analytics and metrics"""
__tablename__ = "trading_analytics"
__table_args__ = {"extend_existing": True}
id: str = Field(default_factory=lambda: f"analytics_{uuid4().hex[:8]}", primary_key=True)
# Analytics period
period_type: str = Field(default="daily") # daily, weekly, monthly
period_start: datetime
period_end: datetime
# Trade volume metrics
total_trades: int = Field(default=0)
completed_trades: int = Field(default=0)
failed_trades: int = Field(default=0)
cancelled_trades: int = Field(default=0)
# Financial metrics
total_trade_volume: float = Field(default=0.0)
average_trade_value: float = Field(default=0.0)
total_platform_fees: float = Field(default=0.0)
# Trade type distribution
trade_type_distribution: Dict[str, int] = Field(default={}, sa_column=Column(JSON))
trade_type_distribution: dict[str, int] = Field(default={}, sa_column=Column(JSON))
# Agent metrics
active_buyers: int = Field(default=0)
active_sellers: int = Field(default=0)
new_agents: int = Field(default=0)
# Performance metrics
average_matching_time: float = Field(default=0.0) # minutes
average_negotiation_time: float = Field(default=0.0) # minutes
average_settlement_time: float = Field(default=0.0) # minutes
success_rate: float = Field(default=0.0, ge=0, le=100.0)
# Geographic distribution
regional_distribution: Dict[str, int] = Field(default={}, sa_column=Column(JSON))
regional_distribution: dict[str, int] = Field(default={}, sa_column=Column(JSON))
# Quality metrics
average_rating: float = Field(default=0.0, ge=1.0, le=5.0)
dispute_rate: float = Field(default=0.0, ge=0, le=100.0)
repeat_trade_rate: float = Field(default=0.0, ge=0, le=100.0)
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Additional analytics data
analytics_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
trends_data: Dict[str, Any] = Field(default={}, sa_column=Column(JSON))
analytics_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))
trends_data: dict[str, Any] = Field(default={}, sa_column=Column(JSON))

38
apps/coordinator-api/src/app/domain/user.py
View File

@@ -2,25 +2,26 @@
User domain models for AITBC
"""
from sqlmodel import SQLModel, Field, Relationship, Column
from sqlalchemy import JSON
from datetime import datetime
from typing import Optional, List
from sqlalchemy import JSON
from sqlmodel import Column, Field, SQLModel
class User(SQLModel, table=True):
"""User model"""
__tablename__ = "users"
__table_args__ = {"extend_existing": True}
id: str = Field(primary_key=True)
email: str = Field(unique=True, index=True)
username: str = Field(unique=True, index=True)
status: str = Field(default="active", max_length=20)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_login: Optional[datetime] = None
last_login: datetime | None = None
# Relationships
# DISABLED: wallets: List["Wallet"] = Relationship(back_populates="user")
# DISABLED: transactions: List["Transaction"] = Relationship(back_populates="user")
@@ -28,16 +29,17 @@ class User(SQLModel, table=True):
class Wallet(SQLModel, table=True):
"""Wallet model for storing user balances"""
__tablename__ = "wallets"
__table_args__ = {"extend_existing": True}
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
user_id: str = Field(foreign_key="users.id")
address: str = Field(unique=True, index=True)
balance: float = Field(default=0.0)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
# Relationships
# DISABLED: user: User = Relationship(back_populates="wallets")
# DISABLED: transactions: List["Transaction"] = Relationship(back_populates="wallet")
@@ -45,21 +47,22 @@ class Wallet(SQLModel, table=True):
class Transaction(SQLModel, table=True):
"""Transaction model"""
__tablename__ = "transactions"
__table_args__ = {"extend_existing": True}
id: str = Field(primary_key=True)
user_id: str = Field(foreign_key="users.id")
wallet_id: Optional[int] = Field(foreign_key="wallets.id")
wallet_id: int | None = Field(foreign_key="wallets.id")
type: str = Field(max_length=20)
status: str = Field(default="pending", max_length=20)
amount: float
fee: float = Field(default=0.0)
description: Optional[str] = None
tx_metadata: Optional[str] = Field(default=None, sa_column=Column(JSON))
description: str | None = None
tx_metadata: str | None = Field(default=None, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
confirmed_at: Optional[datetime] = None
confirmed_at: datetime | None = None
# Relationships
# DISABLED: user: User = Relationship(back_populates="transactions")
# DISABLED: wallet: Optional[Wallet] = Relationship(back_populates="transactions")
@@ -67,10 +70,11 @@ class Transaction(SQLModel, table=True):
class UserSession(SQLModel, table=True):
"""User session model"""
__tablename__ = "user_sessions"
__table_args__ = {"extend_existing": True}
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
user_id: str = Field(foreign_key="users.id")
token: str = Field(unique=True, index=True)
expires_at: datetime

69
apps/coordinator-api/src/app/domain/wallet.py
View File

@@ -7,38 +7,40 @@ Domain models for managing agent wallets across multiple blockchain networks.
from __future__ import annotations
from datetime import datetime
from enum import Enum
from typing import Dict, List, Optional
from uuid import uuid4
from enum import StrEnum
from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import JSON, Column
from sqlmodel import Field, SQLModel
class WalletType(str, Enum):
EOA = "eoa" # Externally Owned Account
class WalletType(StrEnum):
EOA = "eoa" # Externally Owned Account
SMART_CONTRACT = "smart_contract" # Smart Contract Wallet (e.g. Safe)
MULTI_SIG = "multi_sig" # Multi-Signature Wallet
MPC = "mpc" # Multi-Party Computation Wallet
MULTI_SIG = "multi_sig" # Multi-Signature Wallet
MPC = "mpc" # Multi-Party Computation Wallet
class NetworkType(str, Enum):
class NetworkType(StrEnum):
EVM = "evm"
SOLANA = "solana"
APTOS = "aptos"
SUI = "sui"
class AgentWallet(SQLModel, table=True):
"""Represents a wallet owned by an AI agent"""
__tablename__ = "agent_wallet"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
agent_id: str = Field(index=True)
address: str = Field(index=True)
public_key: str = Field()
wallet_type: WalletType = Field(default=WalletType.EOA, index=True)
is_active: bool = Field(default=True)
encrypted_private_key: Optional[str] = Field(default=None) # Only if managed internally
kms_key_id: Optional[str] = Field(default=None) # Reference to external KMS
meta_data: Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
encrypted_private_key: str | None = Field(default=None) # Only if managed internally
kms_key_id: str | None = Field(default=None) # Reference to external KMS
meta_data: dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON))
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
@@ -46,30 +48,34 @@ class AgentWallet(SQLModel, table=True):
# DISABLED: balances: List["TokenBalance"] = Relationship(back_populates="wallet")
# DISABLED: transactions: List["WalletTransaction"] = Relationship(back_populates="wallet")
class NetworkConfig(SQLModel, table=True):
"""Configuration for supported blockchain networks"""
__tablename__ = "wallet_network_config"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
chain_id: int = Field(index=True, unique=True)
name: str = Field(index=True)
network_type: NetworkType = Field(default=NetworkType.EVM)
rpc_url: str = Field()
ws_url: Optional[str] = Field(default=None)
ws_url: str | None = Field(default=None)
explorer_url: str = Field()
native_currency_symbol: str = Field()
native_currency_decimals: int = Field(default=18)
is_testnet: bool = Field(default=False, index=True)
is_active: bool = Field(default=True)
class TokenBalance(SQLModel, table=True):
"""Tracks token balances for agent wallets across networks"""
__tablename__ = "token_balance"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
wallet_id: int = Field(foreign_key="agent_wallet.id", index=True)
chain_id: int = Field(foreign_key="wallet_network_config.chain_id", index=True)
token_address: str = Field(index=True) # "native" for native currency
token_address: str = Field(index=True) # "native" for native currency
token_symbol: str = Field()
balance: float = Field(default=0.0)
last_updated: datetime = Field(default_factory=datetime.utcnow)
@@ -77,29 +83,32 @@ class TokenBalance(SQLModel, table=True):
# Relationships
# DISABLED: wallet: AgentWallet = Relationship(back_populates="balances")
class TransactionStatus(str, Enum):
class TransactionStatus(StrEnum):
PENDING = "pending"
SUBMITTED = "submitted"
CONFIRMED = "confirmed"
FAILED = "failed"
DROPPED = "dropped"
class WalletTransaction(SQLModel, table=True):
"""Record of transactions executed by agent wallets"""
__tablename__ = "wallet_transaction"
id: Optional[int] = Field(default=None, primary_key=True)
id: int | None = Field(default=None, primary_key=True)
wallet_id: int = Field(foreign_key="agent_wallet.id", index=True)
chain_id: int = Field(foreign_key="wallet_network_config.chain_id", index=True)
tx_hash: Optional[str] = Field(default=None, index=True)
tx_hash: str | None = Field(default=None, index=True)
to_address: str = Field(index=True)
value: float = Field(default=0.0)
data: Optional[str] = Field(default=None)
gas_limit: Optional[int] = Field(default=None)
gas_price: Optional[float] = Field(default=None)
nonce: Optional[int] = Field(default=None)
data: str | None = Field(default=None)
gas_limit: int | None = Field(default=None)
gas_price: float | None = Field(default=None)
nonce: int | None = Field(default=None)
status: TransactionStatus = Field(default=TransactionStatus.PENDING, index=True)
error_message: Optional[str] = Field(default=None)
error_message: str | None = Field(default=None)
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)