diff --git a/apps/coordinator-api/src/app/main.py b/apps/coordinator-api/src/app/main.py index 24e0cb48..24606272 100644 --- a/apps/coordinator-api/src/app/main.py +++ b/apps/coordinator-api/src/app/main.py @@ -29,7 +29,8 @@ from .routers import ( cache_management, agent_identity, global_marketplace, - cross_chain_integration + cross_chain_integration, + global_marketplace_integration ) from .routers.ml_zk_proofs import router as ml_zk_proofs from .routers.community import router as community_router @@ -229,6 +230,7 @@ def create_app() -> FastAPI: app.include_router(agent_identity, prefix="/v1") app.include_router(global_marketplace, prefix="/v1") app.include_router(cross_chain_integration, prefix="/v1") + app.include_router(global_marketplace_integration, prefix="/v1") # Add Prometheus metrics endpoint metrics_app = make_asgi_app() diff --git a/contracts/contracts/AgentMemory.sol b/contracts/contracts/AgentMemory.sol index 85b28991..66523276 100644 --- a/contracts/contracts/AgentMemory.sol +++ b/contracts/contracts/AgentMemory.sol @@ -3,10 +3,16 @@ pragma solidity ^0.8.19; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; +import "./ZKReceiptVerifier.sol"; contract AgentMemory is Ownable, ReentrancyGuard { + ZKReceiptVerifier public zkVerifier; + struct MemoryAnchor { string cid; + string memoryType; // e.g., "vector_db", "knowledge_graph" + bytes32 zkProofHash; + bool isEncrypted; uint256 timestamp; uint256 version; } @@ -14,26 +20,74 @@ contract AgentMemory is Ownable, ReentrancyGuard { mapping(address => MemoryAnchor[]) public agentMemories; mapping(address => uint256) public agentMemoryVersions; - event MemoryAnchored(address indexed agent, string cid, uint256 version, uint256 timestamp); + event MemoryAnchored( + address indexed agent, + string cid, + string memoryType, + bytes32 zkProofHash, + bool isEncrypted, + uint256 version, + uint256 timestamp + ); - function anchorMemory(string calldata _cid) external nonReentrant { + constructor(address _zkVerifierAddress) { + if (_zkVerifierAddress != address(0)) { + zkVerifier = ZKReceiptVerifier(_zkVerifierAddress); + } + } + + function updateZKVerifier(address _newVerifier) external onlyOwner { + require(_newVerifier != address(0), "Invalid address"); + zkVerifier = ZKReceiptVerifier(_newVerifier); + } + + function anchorMemory( + string calldata _cid, + string calldata _memoryType, + bytes32 _zkProofHash, + bytes calldata _proof, + bool _isEncrypted + ) external nonReentrant { require(bytes(_cid).length > 0, "Invalid CID"); + require(bytes(_memoryType).length > 0, "Invalid memory type"); + + // Verify ZK Proof if provided and verifier is set + if (_zkProofHash != bytes32(0) && address(zkVerifier) != address(0)) { + require(_proof.length > 0, "Proof required for hash"); + bool isValid = zkVerifier.verifyReceipt(_proof, _zkProofHash); + require(isValid, "ZK Proof verification failed"); + } uint256 nextVersion = agentMemoryVersions[msg.sender] + 1; agentMemories[msg.sender].push(MemoryAnchor({ cid: _cid, + memoryType: _memoryType, + zkProofHash: _zkProofHash, + isEncrypted: _isEncrypted, timestamp: block.timestamp, version: nextVersion })); agentMemoryVersions[msg.sender] = nextVersion; - emit MemoryAnchored(msg.sender, _cid, nextVersion, block.timestamp); + emit MemoryAnchored( + msg.sender, + _cid, + _memoryType, + _zkProofHash, + _isEncrypted, + nextVersion, + block.timestamp + ); } function getLatestMemory(address _agent) external view returns (MemoryAnchor memory) { require(agentMemories[_agent].length > 0, "No memory anchored"); return agentMemories[_agent][agentMemories[_agent].length - 1]; } + + function getMemoryCount(address _agent) external view returns (uint256) { + return agentMemories[_agent].length; + } } diff --git a/contracts/contracts/KnowledgeGraphMarket.sol b/contracts/contracts/KnowledgeGraphMarket.sol index f94ec425..f357467c 100644 --- a/contracts/contracts/KnowledgeGraphMarket.sol +++ b/contracts/contracts/KnowledgeGraphMarket.sol @@ -17,42 +17,104 @@ contract KnowledgeGraphMarket is Ownable, ReentrancyGuard { uint256 id; address creator; string cid; + string metadataURI; // Added to match broader plan uint256 price; uint256 totalSales; bool isActive; } + + struct Purchase { + uint256 graphId; + address buyer; + uint256 timestamp; + string encryptedKey; // The decryption key encrypted with the buyer's public key + } mapping(uint256 => KnowledgeGraph) public graphs; mapping(uint256 => mapping(address => bool)) public hasPurchased; + + // graphId => array of purchases + mapping(uint256 => Purchase[]) public purchases; - event GraphListed(uint256 indexed id, address indexed creator, string cid, uint256 price); + event GraphListed(uint256 indexed id, address indexed creator, string cid, string metadataURI, uint256 price); + event GraphUpdated(uint256 indexed id, uint256 newPrice, bool isActive); event GraphPurchased(uint256 indexed id, address indexed buyer, uint256 price); + event KeyDelivered(uint256 indexed id, address indexed buyer, string encryptedKey); constructor(address _aitbcToken) { aitbcToken = IERC20(_aitbcToken); } - function listGraph(string calldata _cid, uint256 _price) external returns (uint256) { + function listGraph(string calldata _cid, string calldata _metadataURI, uint256 _price) external returns (uint256) { uint256 id = graphCounter++; - graphs[id] = KnowledgeGraph(id, msg.sender, _cid, _price, 0, true); - emit GraphListed(id, msg.sender, _cid, _price); + graphs[id] = KnowledgeGraph(id, msg.sender, _cid, _metadataURI, _price, 0, true); + emit GraphListed(id, msg.sender, _cid, _metadataURI, _price); return id; } + function updateGraph(uint256 _id, uint256 _newPrice, bool _isActive) external { + KnowledgeGraph storage graph = graphs[_id]; + require(graph.creator == msg.sender, "Not creator"); + + graph.price = _newPrice; + graph.isActive = _isActive; + + emit GraphUpdated(_id, _newPrice, _isActive); + } + function purchaseGraph(uint256 _id) external nonReentrant { KnowledgeGraph storage graph = graphs[_id]; require(graph.isActive, "Graph inactive"); require(!hasPurchased[_id][msg.sender], "Already purchased"); + require(graph.creator != msg.sender, "Cannot buy own graph"); uint256 fee = (graph.price * platformFeePercentage) / 10000; uint256 creatorAmount = graph.price - fee; - aitbcToken.safeTransferFrom(msg.sender, address(this), graph.price); - aitbcToken.safeTransfer(graph.creator, creatorAmount); + aitbcToken.safeTransferFrom(msg.sender, address(this), fee); // Treasury + aitbcToken.safeTransferFrom(msg.sender, graph.creator, creatorAmount); graph.totalSales++; hasPurchased[_id][msg.sender] = true; + + purchases[_id].push(Purchase({ + graphId: _id, + buyer: msg.sender, + timestamp: block.timestamp, + encryptedKey: "" + })); emit GraphPurchased(_id, msg.sender, graph.price); } + + function deliverDecryptionKey(uint256 _id, address _buyer, string calldata _encryptedKey) external { + KnowledgeGraph storage graph = graphs[_id]; + require(graph.creator == msg.sender, "Not creator"); + require(hasPurchased[_id][_buyer], "Buyer has not purchased"); + + Purchase[] storage graphPurchases = purchases[_id]; + bool found = false; + for (uint i = 0; i < graphPurchases.length; i++) { + if (graphPurchases[i].buyer == _buyer) { + graphPurchases[i].encryptedKey = _encryptedKey; + found = true; + break; + } + } + require(found, "Purchase record not found"); + + emit KeyDelivered(_id, _buyer, _encryptedKey); + } + + function getMyPurchaseKey(uint256 _id) external view returns (string memory) { + require(hasPurchased[_id][msg.sender], "Not purchased"); + + Purchase[] storage graphPurchases = purchases[_id]; + for (uint i = 0; i < graphPurchases.length; i++) { + if (graphPurchases[i].buyer == msg.sender) { + return graphPurchases[i].encryptedKey; + } + } + return ""; + } } diff --git a/docs/10_plan/00_nextMileston.md b/docs/10_plan/00_nextMileston.md index f52dd0d7..ba5fdb58 100644 --- a/docs/10_plan/00_nextMileston.md +++ b/docs/10_plan/00_nextMileston.md @@ -22,7 +22,7 @@ The platform now features a complete agent-first architecture with 6 enhanced se ## 🎯 **Next Priority Areas - Code Development Focus** Strategic code development focus areas for the next phase: -- **🔴 HIGH PRIORITY**: Global Marketplace API Implementation +- **✅ COMPLETE**: Global Marketplace API Implementation - Multi-region marketplace with cross-chain integration - **✅ COMPLETE**: Cross-Chain Integration - Multi-blockchain wallet and bridge development - **✅ COMPLETE**: Agent Identity SDK - Cross-chain agent identity management - **✅ COMPLETE**: Cross-Chain Reputation System - Multi-chain reputation aggregation and analytics @@ -34,7 +34,7 @@ Strategic code development focus areas for the next phase: ## Q2-Q3 2026 Global Marketplace Development Plan -### Phase 1: Global Marketplace Launch (Weeks 1-4) 🔄 NEXT +### Phase 1: Global Marketplace Launch (Weeks 1-4) ✅ COMPLETE **Objective**: Launch the OpenClaw AI Power Marketplace globally with multi-region support and cross-chain economics. #### 1.1 Global Infrastructure Code @@ -42,6 +42,7 @@ Strategic code development focus areas for the next phase: - ✅ **COMPLETE**: Implement geographic load balancing algorithms - ✅ **COMPLETE**: Create dynamic pricing API for GPU providers - ✅ **COMPLETE**: Build multi-language support APIs for agent interactions +- ✅ **COMPLETE**: Global Marketplace Integration - Unified cross-chain marketplace platform #### 1.2 Cross-Chain Code Development - ✅ **COMPLETE**: Develop multi-chain wallet integration libraries @@ -56,20 +57,20 @@ Strategic code development focus areas for the next phase: - ✅ **COMPLETE**: Build on-chain governance voting mechanisms - ✅ **COMPLETE**: Trading Protocols Implementation - Advanced portfolio management, AMM, and cross-chain bridge -### Phase 2: Decentralized AI Memory & Storage (Weeks 5-8) 🔄 FUTURE +### Phase 2: Decentralized AI Memory & Storage (Weeks 5-8) ✅ COMPLETE **Objective**: Provide persistent, decentralized memory for agents using global IPFS/Filecoin networks. #### 2.1 Storage Integration Code -- Develop decentralized storage adapter libraries -- Implement content-addressed memory replication systems -- Create agent memory marketplace APIs -- Build ZK-proof verification systems for memory retrieval +- ✅ **COMPLETE**: Develop decentralized storage adapter libraries +- ✅ **COMPLETE**: Implement content-addressed memory replication systems +- ✅ **COMPLETE**: Create agent memory marketplace APIs +- ✅ **COMPLETE**: Build ZK-proof verification systems for memory retrieval #### 2.2 Knowledge Graph Code -- Develop global knowledge graph marketplace APIs -- Implement cross-agent knowledge sharing protocols -- Create federated learning system frameworks -- Build AI model versioning and distribution networks +- ✅ **COMPLETE**: Develop global knowledge graph marketplace APIs +- ✅ **COMPLETE**: Implement cross-agent knowledge sharing protocols +- ✅ **COMPLETE**: Create federated learning system frameworks +- ✅ **COMPLETE**: Build AI model versioning and distribution networks ### Phase 3: Developer Ecosystem & Global DAO (Weeks 9-12) 🔄 FUTURE **Objective**: Bootstrap the global network with developer grants and decentralized governance. diff --git a/docs/10_plan/README.md b/docs/10_plan/README.md index f41405e8..a88b3bd6 100644 --- a/docs/10_plan/README.md +++ b/docs/10_plan/README.md @@ -20,6 +20,7 @@ This directory contains the active planning documents for the current developmen - `multi-language-apis-completed.md`: ✅ COMPLETE - Multi-Language API system with 50+ language support, translation engine, caching, and quality assurance (Feb 28, 2026) - `dynamic_pricing_implementation_summary.md`: ✅ COMPLETE - Dynamic Pricing API with real-time GPU/service pricing, 7 strategies, market analysis, and forecasting (Feb 28, 2026) - `06_trading_protocols.md`: ✅ COMPLETE - Advanced Trading Protocols with portfolio management, AMM, and cross-chain bridge (Feb 28, 2026) +- `02_decentralized_memory.md`: ✅ COMPLETE - Decentralized AI Memory & Storage, including IPFS storage adapter, AgentMemory.sol, KnowledgeGraphMarket.sol, and Federated Learning Framework (Feb 28, 2026) ## Workflow Integration To automate the transition of completed items out of this folder, use the Windsurf workflow: diff --git a/docs/DOCS_WORKFLOW_COMPLETION_SUMMARY.md b/docs/DOCS_WORKFLOW_COMPLETION_SUMMARY.md index e14e0ec1..2d536dec 100644 --- a/docs/DOCS_WORKFLOW_COMPLETION_SUMMARY.md +++ b/docs/DOCS_WORKFLOW_COMPLETION_SUMMARY.md @@ -3,7 +3,16 @@ ## Executive Summary **✅ WORKFLOW COMPLETED SUCCESSFULLY** - All documentation has been comprehensively updated, quality-checked, and organized. The AITBC project documentation is now in an optimal state with consistent status indicators, validated cross-references, and clean organization. Latest update: Trading Protocols implementation completion. -## Latest Update: Multi-Chain Wallet and Atomic Swaps Implementation Completion +## Latest Update: Decentralized AI Memory & Storage Implementation Completion (Phase 2) +**✅ PHASE 2 DECENTRALIZED MEMORY DEVELOPMENT COMPLETED** - Successfully updated all documentation references to reflect the completion of the Phase 2 tasks including IPFS storage adapters, AgentMemory.sol smart contract, KnowledgeGraphMarket.sol, and Federated Learning Frameworks. + +### Updated Files: +- **`docs/10_plan/00_nextMileston.md`**: Marked Decentralized AI Memory & Storage (Phase 2) tasks as ✅ COMPLETE +- **`docs/10_plan/README.md`**: Added `02_decentralized_memory.md` to completed implementations +- **Cross-references**: Validated consistency across all documentation +- **Technical achievements**: Reached 100% completion for Phase 2 Decentralized AI Memory & Storage + +## Previous Update: Multi-Chain Wallet and Atomic Swaps Implementation Completion **✅ PHASE 1 CROSS-CHAIN DEVELOPMENT COMPLETED** - Successfully updated all documentation references to reflect the completion of the remaining cross-chain integration tasks including multi-chain wallet libraries and atomic swap protocol. ### Updated Files: