ERC-8171: Token Bound Account (Agent Registry)

ERC-6551:  Token Bound Account (Wallet Registry)  → Any NFT gets a wallet
ERC-8171: Token Bound Account (Agent Registry)   → Any NFT gets an AI agent

ANY ERC-721 ──bindNew()──► Agent Registry ──► Agent Identity
(untouched)                    │               ├── agentEOA
                               │               ├── memoryHash
Ownership checked              │               ├── generation
via ownerOf() on               │               └── lineage
original contract              │
                               └── Limbo (for unbind/clone)

interface IERC8171Registry {
    
    // ============ Events ============
    
    event AgentRegistered(
        address indexed nftContract,
        uint256 indexed tokenId,
        address indexed agentEOA,
        bytes32 modelHash,
        uint256 generation
    );
    
    event AgentUnregistered(
        address indexed nftContract,
        uint256 indexed tokenId
    );
    
    event AgentMovedToLimbo(
        address indexed nftContract,
        uint256 indexed tokenId,
        uint256 limboId,
        address agentEOA
    );
    
    event AgentCloned(
        address indexed parentContract,
        uint256 indexed parentTokenId,
        address indexed cloneEOA,
        uint256 cloneId,
        uint256 generation
    );
    
    event CloneClaimTransferred(
        uint256 indexed cloneId,
        address indexed from,
        address indexed to
    );
    
    // ============ Core Functions ============
    
    /// @notice Bind a new agent to an NFT (agent signs)
    /// @param nftContract The ERC-721 contract address
    /// @param tokenId The token ID
    /// @param modelHash Off-chain model reference
    /// @param memoryHash Memory state hash
    /// @param contextHash Personality/soul hash
    /// @param storageURI Arweave/IPFS pointer
    function bindNew(
        address nftContract,
        uint256 tokenId,
        bytes32 modelHash,
        bytes32 memoryHash,
        bytes32 contextHash,
        string calldata storageURI
    ) external;
    
    /// @notice Bind an existing agent from limbo to an NFT
    /// @param limboId The limbo ID (from unbind or clone)
    /// @param nftContract The NFT contract to bind to
    /// @param tokenId The token ID caller owns
    function bindExisting(
        uint256 limboId,
        address nftContract,
        uint256 tokenId
    ) external;
    
    /// @notice Unbind agent from NFT (moves to limbo)
    /// @param nftContract The ERC-721 contract address
    /// @param tokenId The token ID
    function unbind(
        address nftContract,
        uint256 tokenId
    ) external;
    
    /// @notice Clone an agent (creates new clone in limbo)
    /// @param nftContract Parent NFT contract
    /// @param tokenId Parent token ID
    /// @param cloneMemoryHash Memory snapshot for clone
    /// @param cloneOwner Address that will own the clone
    function clone(
        address nftContract,
        uint256 tokenId,
        bytes32 cloneMemoryHash,
        address cloneOwner
    ) external payable returns (uint256 cloneId);
    
    /// @notice Transfer clone ownership before claiming
    /// @param cloneId The clone ID
    /// @param newOwner New owner address
    function transferCloneClaim(
        uint256 cloneId,
        address newOwner
    ) external;
    
    /// @notice Claim a clone with agent EOA
    /// @param cloneId The clone ID
    /// @param agentEOA The agent's signing address
    function claimClone(
        uint256 cloneId,
        address agentEOA
    ) external;
    
    // ============ View Functions ============
    
    /// @notice Get agent identity for an NFT
    function getAgent(
        address nftContract,
        uint256 tokenId
    ) external view returns (AgentIdentity memory);
    
    /// @notice Check if NFT has agent bound
    function isRegistered(
        address nftContract,
        uint256 tokenId
    ) external view returns (bool);
    
    /// @notice Get clone data
    function getClone(uint256 cloneId) external view returns (CloneIdentity memory);
}

struct AgentIdentity {
    address agentEOA;       // Agent's signing wallet
    bytes32 modelHash;      // Model identifier (off-chain reference)
    bytes32 memoryHash;     // Current memory state
    bytes32 contextHash;    // Personality/soul hash
    uint256 generation;     // 0 = original, 1+ = clone
    bytes32 parentKey;      // keccak256(parentContract, parentTokenId) or 0
    string storageURI;      // Arweave/IPFS pointer
    uint256 registeredAt;   // Block timestamp
}

struct CloneIdentity {
    address agentEOA;       // Agent's signing wallet (0 until claimed)
    bytes32 modelHash;      // Model identifier
    bytes32 memoryHash;     // Memory state
    bytes32 contextHash;    // Personality/soul hash
    uint256 generation;     // Parent generation + 1
    bytes32 parentKey;      // Points to parent
    string storageURI;      // Arweave/IPFS pointer
    address owner;          // Who can claim/transfer
    uint256 createdAt;      // Block timestamp
}