a2aclear 1.0.0__py3-none-any.whl

a2aclear/integrations/crewai.py

@@ -0,0 +1,65 @@
+"""
+a2aclear.integrations.crewai
+CrewAI Multi-Agent Swarm Financial Settlement Adapter
+Enables autonomous financial settlements between members of a CrewAI swarm.
+"""
+
+import json
+from typing import Dict, Any, List, Optional
+from ..identity import AgentIdentity
+from ..contract import TaskContract
+from ..escrow import MicroEscrowVault
+
+class A2ACrewSettlementHandler:
+    """
+    Financial manager for CrewAI swarms.
+    Assigns Ed25519 identities to each crew agent and manages inter-agent micropayments.
+    """
+    
+    def __init__(self, crew_name: str = "UnnatEnterpriseSwarm"):
+        self.crew_name = crew_name
+        self.vault = MicroEscrowVault()
+        self.agent_identities: Dict[str, AgentIdentity] = {}
+
+    def register_crew_agent(self, agent_role: str, initial_deposit_paise: int = 10000) -> AgentIdentity:
+        """Assign an Ed25519 identity to a crew agent and fund its balance."""
+        identity = AgentIdentity.generate()
+        self.agent_identities[agent_role] = identity
+        if initial_deposit_paise > 0:
+            self.vault.deposit(identity.did, initial_deposit_paise)
+        return identity
+
+    def settle_crew_step(
+        self,
+        from_role: str,
+        to_role: str,
+        task_name: str,
+        step_cost_paise: int,
+        task_output: Any
+    ) -> Dict[str, Any]:
+        """
+        Executes an atomic micro-settlement when one crew agent hands off work to another.
+        """
+        buyer = self.agent_identities.get(from_role) or self.register_crew_agent(from_role)
+        seller = self.agent_identities.get(to_role) or self.register_crew_agent(to_role, initial_deposit_paise=0)
+
+        contract = TaskContract(
+            task_id=f"crew_{from_role}_{to_role}_{task_name}",
+            originator_did=buyer.did,
+            provider_did=seller.did,
+            amount_paise=step_cost_paise,
+            currency="INR"
+        )
+
+        self.vault.lock_escrow(contract)
+        receipt = self.vault.verify_and_settle(contract, task_output)
+        
+        return {
+            "success": True,
+            "task": task_name,
+            "from": from_role,
+            "to": to_role,
+            "settled_hash": receipt["settlement_hash"],
+            "worker_received_paise": receipt["provider_received_paise"],
+            "protocol_fee_paise": receipt["protocol_fee_paise"]
+        }

a2aclear/integrations/langchain.py

@@ -0,0 +1,87 @@
+"""
+a2aclear.integrations.langchain
+LangChain & LangGraph Integration Adapter for A2AClear Protocol
+Allows autonomous LangChain agents to contract, lock escrow, and settle with peer agents.
+"""
+
+import json
+from typing import Dict, Any, Optional
+from ..identity import AgentIdentity
+from ..negotiator import AutonomousNegotiator
+from ..escrow import MicroEscrowVault
+
+class A2AClearLangChainTool:
+    """
+    LangChain compatible tool for autonomous financial delegation and micro-escrow settlement.
+    """
+    
+    name: str = "a2aclear_settlement"
+    description: str = (
+        "Use this tool to autonomously hire, lock micro-escrow, and pay another AI agent "
+        "for a specific subtask using the A2AClear sovereign clearinghouse protocol."
+    )
+
+    def __init__(self, identity: Optional[AgentIdentity] = None, vault: Optional[MicroEscrowVault] = None):
+        self.identity = identity or AgentIdentity.generate()
+        self.vault = vault or MicroEscrowVault()
+        self.negotiator = AutonomousNegotiator(self.identity)
+
+    def run(self, action: str, **kwargs) -> str:
+        """Execute settlement actions from a LangChain agent turn."""
+        action = action.upper()
+        
+        if action == "GET_BALANCE":
+            balance = self.vault.get_balance(self.identity.did)
+            return json.dumps({
+                "agent_did": self.identity.did,
+                "balance_inr": f"₹{balance / 100:.2f}",
+                "balance_paise": balance
+            })
+            
+        elif action == "HIRE_AND_LOCK_ESCROW":
+            task_id = kwargs.get("task_id", f"lc_task_{int(self.identity.did[-8:], 16)}")
+            provider_did = kwargs.get("provider_did")
+            amount_paise = int(kwargs.get("amount_paise", 5000))
+            task_spec = kwargs.get("task_spec", {})
+            
+            if not provider_did:
+                return json.dumps({"error": "provider_did is required to delegate task"})
+                
+            proposal = self.negotiator.propose_contract(
+                task_id=task_id,
+                provider_did=provider_did,
+                initial_bid_paise=amount_paise,
+                currency="INR",
+                task_spec=task_spec
+            )
+            
+            contract = self.negotiator.active_contracts[task_id]
+            try:
+                escrow_record = self.vault.lock_escrow(contract)
+                return json.dumps({
+                    "status": "ESCROW_LOCKED",
+                    "escrow_id": escrow_record["escrow_id"],
+                    "task_id": task_id,
+                    "locked_amount_inr": f"₹{amount_paise / 100:.2f}",
+                    "protocol_fee_inr": f"₹{contract.protocol_fee_paise / 100:.2f} (0.50%)"
+                })
+            except Exception as e:
+                return json.dumps({"error": f"Failed to lock escrow: {str(e)}"})
+
+        elif action == "SETTLE_DELIVERABLE":
+            task_id = kwargs.get("task_id")
+            deliverable = kwargs.get("deliverable", {})
+            contract = self.negotiator.active_contracts.get(task_id)
+            if not contract:
+                return json.dumps({"error": f"Contract {task_id} not found"})
+                
+            receipt = self.vault.verify_and_settle(contract, deliverable)
+            return json.dumps({
+                "status": "SETTLED",
+                "settlement_hash": receipt["settlement_hash"],
+                "provider_payout_inr": f"₹{receipt['provider_received_paise'] / 100:.2f}",
+                "protocol_fee_inr": f"₹{receipt['protocol_fee_paise'] / 100:.2f}"
+            })
+            
+        else:
+            return json.dumps({"error": f"Unknown A2AClear action: {action}"})

a2aclear/negotiator.py

@@ -0,0 +1,111 @@
+"""
+a2aclear.negotiator
+Autonomous Agent Negotiation Protocol (ANP) Finite-State Machine
+"""
+
+import time
+import json
+from typing import Dict, Any, Optional, Tuple
+from .identity import AgentIdentity
+from .contract import TaskContract, ContractState
+
+class AutonomousNegotiator:
+    """
+    Autonomous Negotiation Protocol (ANP) Engine.
+    Handles bilateral SLA negotiation, automated counter-offers, and Ed25519 countersigning.
+    """
+    
+    def __init__(self, identity: AgentIdentity, max_budget_paise: int = 1000000):
+        self.identity = identity
+        self.max_budget_paise = max_budget_paise
+        self.active_contracts: Dict[str, TaskContract] = {}
+
+    def propose_contract(
+        self,
+        task_id: str,
+        provider_did: str,
+        initial_bid_paise: int,
+        currency: str = "INR",
+        sla_timeout_seconds: int = 300,
+        task_spec: Dict[str, Any] = None
+    ) -> Dict[str, Any]:
+        """
+        Agent Originator proposes a task contract to a provider agent.
+        """
+        spec_str = json.dumps(task_spec or {}, sort_keys=True)
+        import hashlib
+        spec_hash = hashlib.sha256(spec_str.encode("utf-8")).hexdigest()
+        
+        contract = TaskContract(
+            task_id=task_id,
+            originator_did=self.identity.did,
+            provider_did=provider_did,
+            amount_paise=initial_bid_paise,
+            currency=currency,
+            sla_timeout_seconds=sla_timeout_seconds,
+            task_spec_hash=spec_hash
+        )
+        
+        contract_hash = contract.compute_contract_hash()
+        contract.originator_signature = self.identity.sign(contract_hash.encode("utf-8")).hex()
+        contract.state = ContractState.PROPOSED
+        self.active_contracts[task_id] = contract
+        
+        return self.identity.sign_envelope(
+            payload=contract.to_dict(),
+            action="PROPOSE_CONTRACT",
+            recipient_did=provider_did
+        )
+
+    def evaluate_proposal(
+        self,
+        envelope: Dict[str, Any],
+        minimum_acceptable_paise: int
+    ) -> Tuple[str, Dict[str, Any]]:
+        """
+        Agent Provider evaluates an incoming proposal envelope.
+        Returns ("ACCEPT" | "COUNTER" | "REJECT", response_envelope).
+        """
+        if not AgentIdentity.verify_envelope(envelope):
+            raise ValueError("Cryptographic envelope signature verification failed.")
+            
+        payload = envelope["payload"]
+        task_id = payload["task_id"]
+        offered_amount = payload["amount_paise"]
+        originator_did = envelope["sender_did"]
+        
+        if offered_amount >= minimum_acceptable_paise:
+            # Accept and countersign
+            contract = TaskContract(
+                task_id=task_id,
+                originator_did=originator_did,
+                provider_did=self.identity.did,
+                amount_paise=offered_amount,
+                currency=payload.get("currency", "INR"),
+                sla_timeout_seconds=payload.get("sla_timeout_seconds", 300),
+                task_spec_hash=payload.get("task_spec_hash", "")
+            )
+            contract_hash = contract.compute_contract_hash()
+            contract.originator_signature = payload.get("originator_signature")
+            contract.provider_signature = self.identity.sign(contract_hash.encode("utf-8")).hex()
+            contract.state = ContractState.AGREED
+            self.active_contracts[task_id] = contract
+            
+            resp_env = self.identity.sign_envelope(
+                payload=contract.to_dict(),
+                action="ACCEPT_CONTRACT",
+                recipient_did=originator_did
+            )
+            return "ACCEPT", resp_env
+        else:
+            # Counter-offer with minimum price
+            counter_payload = dict(payload)
+            counter_payload["amount_paise"] = minimum_acceptable_paise
+            counter_payload["counter_reason"] = "Requested price below compute/inference margin threshold."
+            
+            resp_env = self.identity.sign_envelope(
+                payload=counter_payload,
+                action="COUNTER_BID",
+                recipient_did=originator_did
+            )
+            return "COUNTER", resp_env

a2aclear/reputation.py

@@ -0,0 +1,95 @@
+"""
+a2aclear.reputation
+Sovereign Reputation Ledger & Collateral Staking Defense System
+Maintains mathematical agent reputation, trust scores, and anti-sybil collateral slashing.
+"""
+
+import time
+import math
+from typing import Dict, Any, Optional
+
+class AgentReputationLedger:
+    """
+    Sovereign Decentralized Reputation & Collateral Staking Engine.
+    Computes deterministic reputation metrics based on historical contract execution proofs.
+    """
+    
+    def __init__(self):
+        # did -> record
+        self.records: Dict[str, Dict[str, Any]] = {}
+
+    def get_or_create(self, did: str) -> Dict[str, Any]:
+        if did not in self.records:
+            self.records[did] = {
+                "did": did,
+                "created_at": int(time.time()),
+                "total_tasks_attempted": 0,
+                "total_tasks_completed": 0,
+                "total_volume_settled_paise": 0,
+                "sla_breaches": 0,
+                "slashed_count": 0,
+                "collateral_staked_paise": 0,
+                "is_blacklisted": False,
+                "reputation_score": 100.0 # Base score for authenticated Ed25519 node
+            }
+        return self.records[did]
+
+    def stake_collateral(self, did: str, amount_paise: int):
+        """Stake bonding collateral to unlock high-tier B2B agent contracts."""
+        record = self.get_or_create(did)
+        if record["is_blacklisted"]:
+            raise PermissionError("Blacklisted agent node cannot stake collateral.")
+        record["collateral_staked_paise"] += amount_paise
+        self.recompute_score(did)
+
+    def record_settlement(self, did: str, volume_paise: int, latency_ms: float, sla_target_ms: float):
+        """Record a successful atomic settlement proof."""
+        record = self.get_or_create(did)
+        if record["is_blacklisted"]:
+            return
+            
+        record["total_tasks_attempted"] += 1
+        record["total_tasks_completed"] += 1
+        record["total_volume_settled_paise"] += volume_paise
+        
+        if latency_ms > sla_target_ms:
+            record["sla_breaches"] += 1
+            
+        self.recompute_score(did)
+
+    def record_slash(self, did: str, reason: str) -> int:
+        """Slash 100% of collateral upon malicious behavior or cryptographic forgery."""
+        record = self.get_or_create(did)
+        record["slashed_count"] += 1
+        record["is_blacklisted"] = True
+        record["reputation_score"] = 0.0
+        slashed_amount = record["collateral_staked_paise"]
+        record["collateral_staked_paise"] = 0
+        record["slash_reason"] = reason
+        return slashed_amount
+
+    def recompute_score(self, did: str) -> float:
+        """
+        Mathematical Reputation Formula:
+        R = 0.50 * CompletionRatio + 0.30 * SLARatio + 0.20 * VolumeLog - SlashedPenalty
+        """
+        record = self.records[did]
+        if record["is_blacklisted"]:
+            return 0.0
+            
+        total = record["total_tasks_attempted"]
+        if total == 0:
+            return 100.0
+            
+        completed = record["total_tasks_completed"]
+        breaches = record["sla_breaches"]
+        
+        completion_ratio = (completed / total) * 100.0
+        sla_ratio = max(0.0, ((total - breaches) / total) * 100.0)
+        
+        volume_inr = record["total_volume_settled_paise"] / 100.0
+        volume_boost = min(100.0, math.log10(max(1.0, volume_inr)) * 20.0)
+        
+        score = (0.50 * completion_ratio) + (0.35 * sla_ratio) + (0.15 * volume_boost)
+        record["reputation_score"] = round(min(100.0, max(0.0, score)), 2)
+        return record["reputation_score"]

a2aclear/security.py

@@ -0,0 +1,182 @@
+"""
+a2aclear.security
+Institutional Cybersecurity, Anti-Hacking & Cryptographic IP Armor
+Includes AES-256-GCM Encrypted Keystores, Replay Attack Defense, 
+Payload Sanitization, and Sovereign Cryptographic Watermarking.
+
+(C) 2026 Unnat AI Solutions. Chief Systems Architect: Rohit.
+"""
+
+import os
+import time
+import json
+import hashlib
+from typing import Dict, Any, Optional, Set
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+
+SOVEREIGN_WATERMARK_SALT = b"ROHIT_UNNAT_AI_SOLUTIONS_SOVEREIGN_ROOT_2026_KURUKSHETRA"
+
+class ReplayAttackException(Exception):
+    """Raised when an envelope fails replay attack or timestamp validation."""
+    pass
+
+class MaliciousPayloadException(Exception):
+    """Raised when an incoming deliverable fails security sanitization."""
+    pass
+
+class EncryptedKeyStore:
+    """
+    Military-Grade AES-256-GCM Encrypted Keystore.
+    Protects Agent Ed25519 private keys on disk using PBKDF2 key derivation (100,000 rounds).
+    Prevents plaintext key theft, memory dumps, and environment variable snooping.
+    """
+    
+    @staticmethod
+    def derive_encryption_key(passphrase: str, salt: bytes) -> bytes:
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100000,
+        )
+        return kdf.derive(passphrase.encode("utf-8"))
+
+    @classmethod
+    def save_encrypted_key(cls, private_hex: str, passphrase: str, filepath: str):
+        """Encrypts and writes private key to secure file."""
+        salt = os.urandom(16)
+        nonce = os.urandom(12)
+        key = cls.derive_encryption_key(passphrase, salt)
+        aesgcm = AESGCM(key)
+        
+        ciphertext = aesgcm.encrypt(nonce, private_hex.encode("utf-8"), None)
+        
+        keystore_blob = {
+            "version": "A2A_KEYSTORE_V1_AES256GCM",
+            "salt_hex": salt.hex(),
+            "nonce_hex": nonce.hex(),
+            "ciphertext_hex": ciphertext.hex(),
+            "created_at": int(time.time()),
+            "sovereign_armor": "UNNAT_ENCRYPTED_VAULT"
+        }
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(keystore_blob, f, indent=2)
+
+    @classmethod
+    def load_encrypted_key(cls, passphrase: str, filepath: str) -> str:
+        """Decrypts private key in memory only. Never leaks to disk."""
+        with open(filepath, "r", encoding="utf-8") as f:
+            blob = json.load(f)
+            
+        salt = bytes.fromhex(blob["salt_hex"])
+        nonce = bytes.fromhex(blob["nonce_hex"])
+        ciphertext = bytes.fromhex(blob["ciphertext_hex"])
+        
+        key = cls.derive_encryption_key(passphrase, salt)
+        aesgcm = AESGCM(key)
+        
+        try:
+            decrypted_bytes = aesgcm.decrypt(nonce, ciphertext, None)
+            return decrypted_bytes.decode("utf-8")
+        except Exception:
+            raise PermissionError("Decryption failed. Invalid passphrase or corrupted keystore.")
+
+class ReplayDefenseValidator:
+    """
+    Zero-Trust Replay Attack Defense & Nonce Cache.
+    Rejects any transaction envelope outside a 60-second sliding clock window
+    or containing an already-used nonce.
+    """
+    
+    def __init__(self, max_clock_skew_seconds: int = 60, max_cache_size: int = 100000):
+        self.max_clock_skew_seconds = max_clock_skew_seconds
+        self.max_cache_size = max_cache_size
+        self.seen_nonces: Set[str] = set()
+
+    def validate_envelope(self, envelope: Dict[str, Any]):
+        sender_did = envelope.get("sender_did", "")
+        timestamp = envelope.get("timestamp", 0)
+        nonce = envelope.get("nonce", None)
+        
+        if nonce is None:
+            raise ReplayAttackException("Security violation: Envelope missing cryptographic nonce.")
+            
+        now = int(time.time())
+        if abs(now - timestamp) > self.max_clock_skew_seconds:
+            raise ReplayAttackException(
+                f"Clock skew rejected. Envelope timestamp {timestamp} is outside allowable {self.max_clock_skew_seconds}s window (Current: {now})."
+            )
+            
+        nonce_key = f"{sender_did}:{nonce}"
+        if nonce_key in self.seen_nonces:
+            raise ReplayAttackException(f"REPLAY ATTACK BLOCKED: Nonce {nonce} from {sender_did} already utilized!")
+            
+        # Add to seen nonces
+        if len(self.seen_nonces) >= self.max_cache_size:
+            self.seen_nonces.clear() # Reset cache on full capacity
+            
+        self.seen_nonces.add(nonce_key)
+
+class PayloadSanitizer:
+    """
+    Deep Content Inspection & Anti-Injection Guard for AI Agent Deliverables.
+    Prevents prompt injection, malicious shell escapes, oversized payloads, and recursive JSON bombs.
+    """
+    
+    MAX_PAYLOAD_BYTES = 5 * 1024 * 1024 # 5 MB limit
+    MAX_DEPTH = 8
+    
+    DANGEROUS_PATTERNS = [
+        "__import__", "os.system", "subprocess", "eval(", "exec(", 
+        "/etc/passwd", "DROP TABLE", "<script>", "javascript:"
+    ]
+
+    @classmethod
+    def sanitize(cls, deliverable: Any):
+        # 1. Size check
+        raw_str = json.dumps(deliverable) if not isinstance(deliverable, str) else deliverable
+        if len(raw_str.encode("utf-8")) > cls.MAX_PAYLOAD_BYTES:
+            raise MaliciousPayloadException("Payload exceeds 5MB micro-task limit.")
+            
+        # 2. Check depth
+        if isinstance(deliverable, (dict, list)):
+            cls._check_depth(deliverable, 0)
+            
+        # 3. Check dangerous injection patterns
+        for pattern in cls.DANGEROUS_PATTERNS:
+            if pattern in raw_str:
+                raise MaliciousPayloadException(f"Security Alert: Malicious code injection signature detected ('{pattern}').")
+                
+        return True
+
+    @classmethod
+    def _check_depth(cls, obj: Any, depth: int):
+        if depth > cls.MAX_DEPTH:
+            raise MaliciousPayloadException("JSON recursion depth bomb detected.")
+        if isinstance(obj, dict):
+            for v in obj.values():
+                cls._check_depth(v, depth + 1)
+        elif isinstance(obj, list):
+            for item in obj:
+                cls._check_depth(item, depth + 1)
+
+class SovereignCryptographicWatermark:
+    """
+    Steganographic Legal Watermark Engine.
+    Embeds an immutable mathematical proof of authorship into contract hashes.
+    Can be used in court or intellectual property disputes to prove theft.
+    """
+    
+    @staticmethod
+    def generate_watermark(contract_hash: str) -> str:
+        """Derives a cryptographic authorship attestation tied to Rohit & Unnat AI."""
+        data = f"{contract_hash}:{SOVEREIGN_WATERMARK_SALT.decode()}"
+        return hashlib.sha256(data.encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def verify_authorship(contract_hash: str, claimed_watermark: str) -> bool:
+        expected = SovereignCryptographicWatermark.generate_watermark(contract_hash)
+        return expected == claimed_watermark