VeriLaw is a cutting-edge legal technology platform that combines AI-powered document analysis with trusted execution environment (TEE) technology to provide secure, verifiable legal compliance checking. The platform leverages EigenCloud, Echo authentication, and cryptographic attestation to ensure document privacy and result integrity.

VeriLaw consists of several interconnected components working together to provide secure legal document analysis:

1. Frontend UI - Modern React-based web application with Echo authentication
2. Chatbot Backend - WebSocket-based AI chat service using Anthropic Claude
3. Main Backend - Flask API for document processing and attestation management
4. TEE Service - Trusted execution environment for secure document analysis
5. Database - Supabase for storing proofs and attestations

• Frontend: React 18, TypeScript, Tailwind CSS, Vite
• Backend: Flask, Python 3.x
• AI Services: Anthropic Claude, OpenAI GPT-4o-mini
• Authentication: Echo SDK by Merit Systems
• TEE Platform: EigenCloud
• Database: Supabase
• Containerization: Docker

• Documents are processed in a secure enclave
• Original documents are automatically deleted after processing
• Cryptographic proofs ensure result integrity
• Zero-knowledge privacy guarantees

• Document Hash: SHA-256 hash of original document
• Result Hash: SHA-256 hash of AI analysis result
• Code Hash: SHA-256 hash of processing code
• Timestamp: ISO timestamp of processing
• Signature: HMAC-SHA256 signature for integrity verification

• Secure user authentication via Echo SDK
• Token-based access control
• Integrated with Merit Systems infrastructure

lawthing/
├── backend/                    # Main Flask backend
│   ├── app/                   # Core application modules
│   │   ├── __init__.py       # Flask app initialization
│   │   ├── attestation.py    # Cryptographic attestation
│   │   ├── eigencloud_client.py # EigenCloud integration
│   │   ├── tee_service.py    # TEE processing service
│   │   └── utils.py          # Utility functions
│   ├── eigen/                # TEE container service
│   │   ├── Dockerfile        # Container configuration
│   │   ├── requirements.txt  # Python dependencies
│   │   └── src/
│   │       └── main.py       # TEE processing logic
│   ├── requirements.txt      # Backend dependencies
│   └── teeUtil.py           # TEE utility functions
├── frontend-ui/              # React frontend application
│   ├── chatbot-backend/      # WebSocket chat service
│   │   ├── main.py          # Chat server implementation
│   │   ├── config.py        # Configuration settings
│   │   └── requirements.txt # Chat service dependencies
│   └── chatbot-frontend/     # React frontend
│       ├── src/             # Source code
│       │   ├── components/  # React components
│       │   ├── lib/         # Utility libraries
│       │   ├── App.tsx      # Main application
│       │   ├── ChatPage.tsx # Chat interface
│       │   └── AboutPage.tsx # Landing page
│       ├── package.json     # Frontend dependencies
│       └── vite.config.ts   # Vite configuration
├── License                   # Project license
└── README.md               # This file

• Python 3.8+
• Node.js 18+
• Docker
• Git

Create .env files in the appropriate directories with the following variables:

# Supabase Configuration
SUPABASE_URL=your_supabase_url
SUPABASE_KEY=your_supabase_key

# TEE Configuration
TEE_SECRET_KEY=your_tee_secret_key
ENCLAVE_ID=verilaw-enclave

# EigenCloud Configuration
EIGENCLOUD_API_BASE=your_eigencloud_url
EIGENCLOUD_JOB_ID=your_job_id
EIGENCLOUD_API_KEY=your_api_key
EIGENCLOUD_MODE=live  # or 'mock' for testing

# Ethereum Configuration (for TEE)
MNEMONIC=your_wallet_mnemonic

ANTHROPIC_API_KEY=your_anthropic_api_key

1. Clone the repository

   git clone <repository-url>
   cd a16z25-main

2. Set up the backend

   cd lawthing/backend
   pip install -r requirements.txt
   python app/__init__.py

3. Set up the TEE service

   cd lawthing/backend/eigen
   pip install -r requirements.txt
   # For Docker deployment:
   docker build -t verilaw-tee .
   docker run --env-file .env -p 8080:8080 verilaw-tee

4. Set up the chatbot backend

   cd lawthing/frontend-ui/chatbot-backend
   pip install -r requirements.txt
   python main.py

5. Set up the frontend

   cd lawthing/frontend-ui/chatbot-frontend
   npm install
   npm run dev

1. Document Upload: User uploads a PDF document via the web interface
2. Encryption: Document is encrypted locally before transmission
3. TEE Processing:
   • Document is sent to EigenCloud TEE environment
   • Document is decrypted inside the secure enclave
   • Text is extracted from the PDF
   • AI analysis is performed using Echo router
   • Document is permanently deleted from TEE
4. Attestation Generation:
   • Cryptographic hashes are computed
   • Attestation package is created and signed
   • Proof is stored in Supabase
5. Result Delivery: Analysis results and proof are returned to user

1. Authentication: User logs in via Echo authentication system
2. Session Management: WebSocket connection established for real-time chat
3. Message Processing: User messages are processed by Anthropic Claude
4. Response Generation: AI provides legal guidance and information
5. Context Management: Conversation history maintained for continuity

POST /upload
Content-Type: multipart/form-data

Response:
{
  "message": "Document analyzed in TEE",
  "proof_url": "/proof/{proof_id}",
  "download_url": "/proof/{proof_id}/download",
  "verify_url": "/proof/{proof_id}/verify",
  "proof": {...},
  "compliance_result": {...}
}

GET /proof/{signature}

Response:
{
  "doc_name": "document.pdf",
  "doc_hash": "sha256_hash",
  "result_hash": "sha256_hash",
  "attestation": {...}
}

GET /proof/{signature}/download

Response: JSON file download

GET /proof/{signature}/verify

Response:
{
  "package_signature_valid": true,
  "tee_attestation_verified": true
}

POST /verify
Content-Type: multipart/form-data
X-API-Key: your_api_key

Response:
{
  "message": "Document verified successfully inside TEE",
  "attestation": {...},
  "compliance_summary": "..."
}

1. Start all services:

   # Terminal 1: Main backend
   cd lawthing/backend && python app/__init__.py
   
   # Terminal 2: TEE service
   cd lawthing/backend/eigen && python src/main.py
   
   # Terminal 3: Chatbot backend
   cd lawthing/frontend-ui/chatbot-backend && python main.py
   
   # Terminal 4: Frontend
   cd lawthing/frontend-ui/chatbot-frontend && npm run dev

2. Access the application:

   • Frontend: http://localhost:5173
   • Main API: http://localhost:5000
   • TEE Service: http://localhost:8080
   • Chat WebSocket: ws://localhost:8765

# Backend tests
cd lawthing/backend
python -m pytest tests/

# Frontend tests
cd lawthing/frontend-ui/chatbot-frontend
npm test

1. Build TEE container:

   cd lawthing/backend/eigen
   docker build -t verilaw-tee .

2. Deploy to EigenCloud:

   eigenx auth generate --store
   eigenx app deploy username/verilaw-tee

• Set EIGENCLOUD_MODE=live for production
• Use secure TEE secret keys
• Configure proper CORS settings
• Set up SSL/TLS certificates
• Configure database connection pooling

1. Environment Variables: Never commit API keys or secrets to version control
2. TEE Security: Use production-grade TEE environments for sensitive data
3. Network Security: Implement proper firewall rules and access controls
4. Data Retention: Configure automatic cleanup of temporary files
5. Audit Logging: Implement comprehensive logging for compliance

• GDPR Compliance: Automatic data deletion after processing
• SOC 2: Audit trail through cryptographic proofs
• HIPAA Ready: Secure processing environment with attestation
• Legal Hold: Immutable proof storage for legal proceedings

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

• Follow PEP 8 for Python code
• Use TypeScript for frontend development
• Write comprehensive tests
• Update documentation for new features
• Follow semantic versioning

This project is licensed under the terms specified in the License file.

For support and questions:

• Create an issue in the GitHub repository
• Contact the development team
• Check the documentation wiki

• Multi-language document support
• Advanced legal reasoning capabilities
• Integration with legal databases
• Mobile application
• API rate limiting and usage analytics
• Enhanced audit and compliance reporting

• Expand to cover additional legal domains
• Integration with blockchain networks for immutable proof storage
• Machine learning model fine-tuning for legal domains
• Enterprise-grade deployment options

VeriLaw - Transforming legal document analysis through AI and cryptographic security.