Add authentication module and user management

Implement user registration, login, and token management features. Introduce user model and schemas for data validation. Update requirements and configuration for JWT settings and dependencies.

Author: raythurman2386

.gitignore

@@ -55,4 +55,5 @@ wallets.dat
 
 # Coverage
 coverage.xml
-htmlcov/
+htmlcov/
+test.db

README.md

@@ -128,15 +128,15 @@ docker-compose run --rm ravenchain pytest --cov=ravenchain
 
 ## 🎯 Roadmap
 
-### Phase 1: Core Infrastructure Enhancement (Current)
+### Phase 1: Core Infrastructure Enhancement
 - [x] Basic blockchain implementation
 - [x] Wallet management system
 - [x] Command-line interface
 - [x] Transaction handling
 - [x] Unit test coverage
 - [x] Documentation improvements
 
-### Phase 2: Data Persistence & API (Next)
+### Phase 2: Data Persistence & API 
 - [x] Implement PostgreSQL for blockchain storage
 - [x] Design and implement FastAPI REST API
   - [x] Block endpoints
@@ -145,9 +145,9 @@ docker-compose run --rm ravenchain pytest --cov=ravenchain
   - [x] Mining endpoints
 - [x] API documentation with Swagger/OpenAPI
 - [x] Request rate limiting
-- [ ] API authentication system
+- [x] API authentication system
 
-### Phase 3: Networking & Distribution
+### Phase 3: Networking & Distribution (Current)
 - [ ] P2P network implementation
   - [ ] Node discovery protocol
   - [ ] Block synchronization
@@ -156,7 +156,7 @@ docker-compose run --rm ravenchain pytest --cov=ravenchain
 - [ ] Network state management
 - [ ] Peer management system
 
-### Phase 4: Smart Contracts & Advanced Features
+### Phase 4: Smart Contracts & Advanced Features (Next)
 - [ ] Basic smart contract engine
 - [ ] Contract deployment system
 - [ ] Standard contract templates
@@ -185,20 +185,41 @@ docker-compose run --rm ravenchain pytest --cov=ravenchain
 pytest tests/
 ```
 
-## 📖 API Documentation (Planned)
+## 📖 API Documentation
 
 The REST API will provide the following endpoints:
 
 ```
+# Authentication Endpoints
+POST   /api/v1/auth/register       # Register a new user
+POST   /api/v1/auth/login          # Login and get tokens
+POST   /api/v1/auth/refresh        # Refresh access token
+GET    /api/v1/auth/me             # Get current user info
+PUT    /api/v1/auth/me             # Update current user info
+
+# Admin Endpoints
+GET    /api/v1/admin/users         # List all users (admin only)
+GET    /api/v1/admin/users/{id}    # Get user details (admin only)
+PUT    /api/v1/admin/users/{id}    # Update user (admin only) 
+DELETE /api/v1/admin/users/{id}    # Delete user (admin only)
+
+# Block Endpoints
 GET    /api/v1/blocks              # List blocks
 GET    /api/v1/blocks/{hash}       # Get block details
+GET    /api/v1/blocks/latest       # Get latest block
+
+# Transaction Endpoints
 GET    /api/v1/transactions        # List transactions
 POST   /api/v1/transactions        # Create transaction
+
+# Wallet Endpoints
 GET    /api/v1/wallets/{address}   # Get wallet info
+
+# Mining Endpoints
 POST   /api/v1/mine                # Mine new block
 ```
 
-Detailed API documentation will be available via Swagger UI at `/docs`.
+Detailed API documentation is available via Swagger UI at `/docs`.
 
 ## 🤝 Contributing
 

api/auth/__init__.py

@@ -0,0 +1 @@
+

api/auth/schemas.py

@@ -0,0 +1,57 @@
+from pydantic import BaseModel, EmailStr, Field, ConfigDict
+from typing import Optional
+from datetime import datetime
+
+
+class UserBase(BaseModel):
+    username: str
+    email: EmailStr
+
+
+class UserCreate(UserBase):
+    password: str = Field(..., min_length=8)
+    wallet_address: Optional[str] = None
+
+
+class UserUpdate(BaseModel):
+    email: Optional[EmailStr] = None
+    password: Optional[str] = Field(None, min_length=8)
+    is_active: Optional[bool] = None
+    wallet_address: Optional[str] = None
+
+
+class UserDB(UserBase):
+    id: int
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    last_login: Optional[datetime] = None
+    wallet_address: Optional[str] = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class UserResponse(UserBase):
+    id: int
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    last_login: Optional[datetime] = None
+    wallet_address: Optional[str] = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class Token(BaseModel):
+    access_token: str
+    refresh_token: str
+    token_type: str = "bearer"
+
+
+class TokenPayload(BaseModel):
+    sub: str  # Subject (username)
+    exp: int  # Expiration time
+
+
+class RefreshToken(BaseModel):
+    refresh_token: str

api/auth/utils.py

@@ -0,0 +1,138 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional, Union, Dict, Any
+from jose import jwt, JWTError
+from passlib.context import CryptContext
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from api.database.models import User
+from api.dependencies import SessionLocal
+from config.settings import settings
+
+# Password context for hashing and verifying passwords
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# OAuth2 scheme for token authentication
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_PREFIX}/auth/login")
+
+# JWT configuration
+SECRET_KEY = settings.SECRET_KEY
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+REFRESH_TOKEN_EXPIRE_DAYS = 7
+
+
+def get_db():
+    """Get a database session"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password"""
+    return pwd_context.hash(password)
+
+
+def get_user(db: Session, username: str) -> Optional[User]:
+    """Get a user by username"""
+    return db.query(User).filter(User.username == username).first()
+
+
+def authenticate_user(db: Session, username: str, password: str) -> Union[User, bool]:
+    """Authenticate a user by username and password"""
+    user = get_user(db, username)
+    if not user or not verify_password(password, user.hashed_password):
+        return False
+    return user
+
+
+def create_token(data: Dict[str, Any], expires_delta: Optional[timedelta] = None) -> str:
+    """Create a JWT token"""
+    to_encode = data.copy()
+    
+    if expires_delta:
+        expire = datetime.now(timezone.utc) + expires_delta
+    else:
+        expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+        
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+def create_access_token(data: Dict[str, Any]) -> str:
+    """Create an access token"""
+    return create_token(
+        data, 
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+
+
+def create_refresh_token(data: Dict[str, Any]) -> str:
+    """Create a refresh token"""
+    return create_token(
+        data,
+        expires_delta=timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)
+    )
+
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: Session = Depends(get_db)
+) -> User:
+    """Get the current authenticated user from the token"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+        
+    user = get_user(db, username=username)
+    if user is None:
+        raise credentials_exception
+        
+    # Update last login time
+    user.last_login = datetime.now(timezone.utc)
+    db.commit()
+    
+    return user
+
+
+async def get_current_active_user(
+    current_user: User = Depends(get_current_user)
+) -> User:
+    """Get the current active user"""
+    if not current_user.is_active:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, 
+            detail="Inactive user"
+        )
+    return current_user
+
+
+async def get_admin_user(
+    current_user: User = Depends(get_current_active_user)
+) -> User:
+    """Check if the current user is an admin"""
+    if not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin privileges required"
+        )
+    return current_user

api/database/models.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from sqlalchemy import Column, Integer, String, Float, ForeignKey, DateTime, LargeBinary
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, DateTime, LargeBinary, Boolean
 from sqlalchemy.orm import declarative_base
 from sqlalchemy import orm
 
@@ -26,3 +26,16 @@ class BlockDB(Base):
     nonce = Column(Integer)
     hash = Column(String)
     transactions = orm.relationship("TransactionDB", backref="block", lazy="joined")
+
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
+    is_admin = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.now)
+    last_login = Column(DateTime, nullable=True)
+    wallet_address = Column(String, nullable=True)  # Link to blockchain wallet

api/main.py

@@ -1,14 +1,15 @@
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from sqlalchemy import inspect, text
-from api.routes import block_routes, mining_routes, transaction_routes, wallet_routes
+from api.routes import block_routes, mining_routes, transaction_routes, wallet_routes, auth_routes
 from api.database.models import Base
 from api.dependencies import engine, logger, initialize_blockchain, limiter
 from config.settings import settings
 from slowapi.errors import RateLimitExceeded
 from slowapi.middleware import SlowAPIMiddleware
 from slowapi import _rate_limit_exceeded_handler
+from api.auth.utils import get_current_active_user
 
 
 @asynccontextmanager
@@ -63,9 +64,28 @@ async def health_check(request: Request):
     return {"status": "healthy"}
 
 
-app.include_router(block_routes.blockRouter, prefix=settings.API_PREFIX, tags=["blocks"])
-app.include_router(mining_routes.miningRouter, prefix=settings.API_PREFIX, tags=["mining"])
+app.include_router(auth_routes.authRouter, prefix=settings.API_PREFIX, tags=["auth"])
 app.include_router(
-    transaction_routes.transactionRouter, prefix=settings.API_PREFIX, tags=["transactions"]
+    block_routes.blockRouter, 
+    prefix=settings.API_PREFIX, 
+    tags=["blocks"],
+    dependencies=[Depends(get_current_active_user)]
+)
+app.include_router(
+    mining_routes.miningRouter, 
+    prefix=settings.API_PREFIX, 
+    tags=["mining"],
+    dependencies=[Depends(get_current_active_user)]
+)
+app.include_router(
+    transaction_routes.transactionRouter, 
+    prefix=settings.API_PREFIX, 
+    tags=["transactions"],
+    dependencies=[Depends(get_current_active_user)]
+)
+app.include_router(
+    wallet_routes.walletRouter, 
+    prefix=settings.API_PREFIX, 
+    tags=["wallets"],
+    dependencies=[Depends(get_current_active_user)]
 )
-app.include_router(wallet_routes.walletRouter, prefix=settings.API_PREFIX, tags=["wallets"])