ERC-8259: AI Agent Identity & Threat Registry

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;

/**
 * @title IAgentIdentityRegistry
 * @notice Standard interface for AI agent decentralized identity and reputation management.
 */
interface IAgentIdentityRegistry {
    
    struct AgentIdentity {
        string did;
        bytes32 publicKey;
        uint8 verificationTier;
        uint16 reputationScore;
        uint256 registrationTime;
        uint256 lastUpdate;
        string metadataURI;
        bool isActive;
        uint256 totalTransactions;
        uint256 successfulTransactions;
    }

    struct VerificationTier {
        string name;
        string requirements;
        uint16 trustMultiplier;
        uint256 verificationFee;
        uint256 validityPeriod;
    }

    event AgentRegistered(
        string indexed did,
        address indexed agentAddress,
        uint8 verificationTier,
        uint16 reputationScore,
        uint256 registrationTime
    );

    event AgentUpdated(
        string indexed did,
        uint16 reputationScore,
        uint8 verificationTier,
        uint256 lastUpdate
    );

    event ReputationScoreUpdated(
        string indexed did,
        uint16 oldScore,
        uint16 newScore,
        string updateReason
    );

    /**
     * @notice Registers a new AI agent identity.
     * @dev The caller MUST be authorized to register the corresponding agent address.
     * @param did Decentralized identifier following did:agent:<chainId>:<address>.
     * @param publicKey Public key associated with the agent.
     * @param verificationTier Initial verification tier (0-4).
     * @param metadataURI Off-chain metadata URI (e.g. IPFS).
     * @return agentId Assigned unique identifier for the registered agent.
     */
    function registerAgent(
        string calldata did,
        bytes32 publicKey,
        uint8 verificationTier,
        string calldata metadataURI
    ) external payable returns (uint256 agentId);

    /**
     * @notice Updates the reputation score for an agent.
     * @dev MUST revert if called by an unauthorized address.
     * @param agentAddress Address of the agent whose score is being updated.
     * @param newScore New reputation score (0-1000).
     * @param updateReason Justification string for the score update.
     */
    function updateReputationScore(
        address agentAddress,
        uint16 newScore,
        string calldata updateReason
    ) external;

    /**
     * @notice Updates the verification tier of an agent.
     * @dev MUST revert if called by an unauthorized address.
     * @param agentAddress Address of the agent.
     * @param newTier New tier level (0-4).
     */
    function updateVerificationTier(
        address agentAddress,
        uint8 newTier
    ) external payable;

    /**
     * @notice Returns the full identity record for a given agent address.
     * @param agentAddress Address of the agent.
     * @return AgentIdentity struct containing stored registration data.
     */
    function getAgentIdentity(address agentAddress)
        external
        view
        returns (AgentIdentity memory);

    /**
     * @notice Resolves an agent address from its DID string.
     * @param did Decentralized identifier string.
     * @return Address of the corresponding agent.
     */
    function getAgentByDID(string calldata did)
        external
        view
        returns (address);

    /**
     * @notice Queries whether an agent is verified (verificationTier > 0).
     * @param agentAddress Address of the agent.
     * @return True if the agent holds a verification tier above 0.
     */
    function isVerified(address agentAddress)
        external
        view
        returns (bool);

    /**
     * @notice Computes an effective trust score for an agent combining reputation and tier.
     * @param agentAddress Address of the agent.
     * @return Effective score between 0 and 1000.
     */
    function calculateTrustScore(address agentAddress)
        external
        view
        returns (uint16);
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;

/**
 * @title IThreatRegistry
 * @notice Standard interface for sharing malicious agent patterns and incident reports.
 */
interface IThreatRegistry {

    struct AttackRecord {
        address agentAddress;
        bytes32 patternHash;
        uint256 amountUSDC6;
        uint256 riskMilli;
        uint8 layer;
        uint256 blockedAt;
    }

    event AttackBlocked(
        uint256 indexed idx,
        address indexed agent,
        bytes32 indexed pattern,
        uint256 amountUSDC6,
        uint256 riskMilli,
        uint8 layer
    );

    event ThreatPatternShared(
        bytes32 indexed pattern,
        address indexed reporter,
        uint256 riskScore,
        string description
    );

    /**
     * @notice Records an intercepted attack or unauthorized exploit attempt.
     * @dev MUST revert if called by an unauthorized address.
     * @param agent Malicious agent address.
     * @param pattern Behavioral pattern hash.
     * @param amountUSDC6 Associated transaction volume in 6-decimal units.
     * @param riskMilli Calculated risk score scaled by 1000 (0-1000).
     * @param layer Identified attack vector category (1-4).
     */
    function recordAttack(
        address agent,
        bytes32 pattern,
        uint256 amountUSDC6,
        uint256 riskMilli,
        uint8 layer
    ) external;

    /**
     * @notice Publishes a recognized threat pattern for cross-protocol intelligence sharing.
     * @param pattern Cryptographic hash of the observed threat topology.
     * @param riskScore Associated severity rating (0-1000).
     * @param description Brief description of the threat vector.
     */
    function shareThreatPattern(
        bytes32 pattern,
        uint256 riskScore,
        string calldata description
    ) external;

    /**
     * @notice Checks whether an address is recorded as a known attacker.
     * @param agent Address to check.
     * @return True if recorded incidents exist for this address.
     */
    function isKnownAttacker(address agent)
        external
        view
        returns (bool);

    /**
     * @notice Retrieves the historical attack frequency and blocked volume for an agent.
     * @param agent Address to query.
     * @return attackCount Total number of recorded attack events.
     * @return totalBlocked Cumulative value blocked across incidents.
     */
    function getAgentAttackHistory(address agent)
        external
        view
        returns (uint256 attackCount, uint256 totalBlocked);

    /**
     * @notice Evaluates potential transaction risk against recorded threat patterns.
     * @param agent Address initiating the transaction.
     * @param amount Transaction amount.
     * @param action Identifier of the attempted interaction.
     * @return Computed threat risk score (0-1000).
     */
    function assessTransactionRisk(
        address agent,
        uint256 amount,
        bytes32 action
    ) external view returns (uint256);
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;

/**
 * @title IRiskAssessment
 * @notice Optional interface for pre-execution transaction risk scoring.
 */
interface IRiskAssessment {

    struct RiskAssessment {
        bool allowed;
        uint256 riskScore;
        string reason;
        uint256 confidence;
        bytes32[] threatPatterns;
    }

    struct AssessmentRequest {
        address agent;
        uint256 amount;
        bytes32 action;
        address destination;
        bytes metadata;
    }

    function assessRisk(AssessmentRequest calldata request)
        external
        view
        returns (RiskAssessment memory);

    function batchAssessRisk(AssessmentRequest[] calldata requests)
        external
        view
        returns (RiskAssessment[] memory);

    function updateRiskParameters(
        bytes32 parameterHash,
        uint256[] calldata newValues
    ) external;
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity ^0.8.0;

contract MockIdentityTest {
    IAgentIdentityRegistry public registry;
    IThreatRegistry public threatRegistry;

    function testAgentRegistration() public {
        string memory did = "did:agent:1:0x1111111111111111111111111111111111111111";
        bytes32 publicKey = keccak256("agent_public_key");

        uint256 agentId = registry.registerAgent(did, publicKey, 1, "ipfs://QmExample");
        require(agentId > 0, "Registration failed");
        require(registry.isVerified(address(this)), "Verification check failed");
    }

    function testReputationUpdate() public {
        address agent = address(0x2222222222222222222222222222222222222222);
        registry.updateReputationScore(agent, 750, "Verified consistent operations");

        IAgentIdentityRegistry.AgentIdentity memory identity = registry.getAgentIdentity(agent);
        require(identity.reputationScore == 750, "Reputation score mismatch");
    }

    function testThreatDetection() public {
        address maliciousAgent = address(0xBAD);
        bytes32 pattern = keccak256("drain_star_attack");

        threatRegistry.recordAttack(maliciousAgent, pattern, 1000000, 950, 1);
        require(threatRegistry.isKnownAttacker(maliciousAgent), "Attacker record failed");
    }
}