StarkMed - Decentralized Medical Records Platform

Revolutionary blockchain-based health passport built on Starknet, providing secure, private, and globally accessible medical credential management.

• 🌐 Live Application: https://stark-med.vercel.app/
• 🎥 Demo Video: Watch on YouTube
• 📚 Documentation: Complete Guide

StarkMed is a cutting-edge decentralized health passport platform that leverages Starknet's advanced blockchain technology to provide secure, private, and verifiable medical credential management. Built with IPFS storage and blockchain technology, StarkMed ensures that patients have complete control over their medical data while enabling instant, global verification.

• End-to-end encryption for all medical records
• Advanced cryptographic protocols ensuring absolute privacy
• Zero-knowledge proof technology for data verification without exposure (planned for future implementation)

• Built on Starknet's high-performance blockchain infrastructure
• IPFS storage for truly decentralized, censorship-resistant data management
• No single point of failure or control

• Generate secure QR codes for immediate credential sharing
• Real-time blockchain verification
• Cross-border medical compatibility

• Seamless integration with verified healthcare providers
• Hospital and medical institution network
• Trusted decentralized provider registry

• Complete ownership of health data
• Granular access control and permissions
• Selective sharing with healthcare providers
• Emergency access protocols

• Tamper-proof medical history storage
• Permanent, verifiable credential records
• Full audit trail of all access and modifications

• CredentialManager Contract: Core contract managing all health credentials
• Provider Registry: Verified healthcare provider management
• Access Control: Granular permission system for data sharing
• Ownership Management: Secure transfer and management capabilities

• Modern UI/UX: Built with React, TypeScript, and Tailwind CSS
• Wallet Integration: Support for ArgentX, Braavos, and other Starknet wallets
• Real-time Updates: Live blockchain state synchronization
• Responsive Design: Mobile-first approach for global accessibility

• IPFS: Decentralized file storage via Pinata
• Blockchain: Immutable credential metadata on Starknet
• Local Cache: Client-side caching for improved performance

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   User Visits   │ -> │  Connect Wallet  │ -> │ Register Patient│
│   StarkMed      │    │ (ArgentX/Braavos)│    │   On-Chain     │
└─────────────────┘    └──────────────────┘    └─────────────────┘

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│Contract Owner   │ -> │  Admin Panel     │ -> │Register Provider│
│   Access        │    │    Access        │    │   On-Chain     │
└─────────────────┘    └──────────────────┘    └─────────────────┘

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│Provider Creates │ -> │Document Upload   │ -> │  IPFS Storage   │
│  New Credential │    │ & Encryption     │    │   (Pinata)      │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                 │
                                 ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Patient       │ <- │  Credential      │ <- │Blockchain Mint  │
│ Notification    │    │   Available      │    │  (Starknet)     │
└─────────────────┘    └──────────────────┘    └─────────────────┘

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Patient        │ -> │  Generate QR     │ -> │Third-Party      │
│ Shares Cred     │    │  Code/Link       │    │ Verification    │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                 │
                                 ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Verification   │ <- │ Blockchain       │ <- │  Input Cred     │
│    Result       │    │   Verification   │    │      ID         │
└─────────────────┘    └──────────────────┘    └─────────────────┘

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│  Credential     │ -> │  Manage Access   │ -> │Grant/Revoke     │
│    Owner        │    │   Modal          │    │  Permissions    │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                 │
                                 ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Authorized    │ <- │ Access Granted   │ <- │ On-Chain Tx     │
│    Viewers      │    │   Confirmed      │    │  Confirmation   │
└─────────────────┘    └──────────────────┘    └─────────────────┘

• Starknet: Layer 2 scaling solution for Ethereum
• Cairo: Smart contract programming language
• Scarb: Cairo package manager and build tool

• React 18: Modern UI library
• TypeScript: Type-safe development
• Vite: Fast build tool and development server
• Tailwind CSS: Utility-first CSS framework
• Starknet Kit: Wallet connection library
• Lucide React: Modern icon library

• IPFS: Decentralized file storage
• Pinata: IPFS pinning service
• RPC Providers: Blockchain node access

StarkMed/
├── credential_manager/          # Smart Contract Layer
│   ├── src/
│   │   ├── credential_manager.cairo    # Main contract
│   │   └── lib.cairo                   # Contract exports
│   ├── tests/                          # Contract tests
│   ├── deploy.js                       # Deployment script
│   ├── Scarb.toml                      # Project configuration
│   └── deployment-sepolia.json         # Deployment info
│
├── frontend/                    # Frontend Application
│   ├── src/
│   │   ├── components/         # UI Components
│   │   ├── contexts/           # React contexts
│   │   ├── hooks/              # Custom hooks
│   │   ├── lib/                # Utilities & contracts
│   │   ├── pages/              # Application pages
│   │   ├── services/           # Business logic
│   │   └── types/              # TypeScript definitions
│   ├── public/                 # Static assets
│   └── package.json            # Dependencies
│
├── LICENSE                     # MIT License
└── README.md                   # This file

• Node.js (v18 or higher)
• Starknet Wallet (ArgentX or Braavos)
• Cairo (for smart contract development)
• Git

git clone https://github.com/rtb-12/starkmed.git
cd starkmed

cd credential_manager

# Install dependencies
scarb build

# Configure environment
cp .env.example .env
# Edit .env with your credentials

# Deploy to Sepolia (optional)
node deploy.js

cd ../frontend

# Install dependencies
npm install

# Configure environment
cp .env.example .env
# Add your Pinata API keys and contract address

# Start development server
npm run dev

Open http://localhost:8080 in your browser and connect your Starknet wallet.

# Pinata IPFS Configuration
VITE_PINATA_API_KEY=your_pinata_api_key
VITE_PINATA_SECRET_KEY=your_pinata_secret_key

# Contract Configuration
VITE_CONTRACT_ADDRESS=0x0746c9da88a54a60f534cfaefae0e72da73e7dc0ad3da449ffe60021622daa45
VITE_NETWORK=sepolia

# Application Configuration
VITE_APP_NAME=StarkMed
VITE_APP_VERSION=1.0.0

# Network Configuration
STARKNET_NETWORK=sepolia
RPC_URL=https://starknet-sepolia.public.blastapi.io

# Account Configuration
ACCOUNT_ADDRESS=your_account_address
PRIVATE_KEY=your_private_key
CONTRACT_OWNER_ADDRESS=your_owner_address

• verify_credential(credential_id) - Verify credential authenticity
• credential_exists(credential_id) - Check if credential exists
• is_provider(address) - Check provider status
• is_patient(address) - Check patient registration
• get_credential_count() - Get total credential count

• issue_credential(patient, metadata_hash) - Issue new credential
• register_patient() - Register as patient

• register_provider(address, name) - Register healthcare provider
• transfer_ownership(new_owner) - Transfer contract ownership

• createCredential(form, walletAddress) - Create new credential
• verifyCredential(credentialId) - Verify credential
• getCredentials() - Get user credentials

• getAllProviders() - Get registered providers
• registerProvider(address, name) - Register new provider
• transferOwnership(newOwner) - Transfer ownership

cd credential_manager
scarb test

cd frontend
npm test

• End-to-end encryption for all medical documents
• Zero-knowledge proofs for verification without data exposure (planned for future implementation)
• Decentralized storage with IPFS prevents single points of failure

• Role-based permissions (Owner, Provider, Patient)
• Granular access control for individual credentials
• Time-limited access with automatic expiration
• Audit trails for all access and modifications

• Owner-only admin functions with on-chain verification
• Input validation for all contract interactions
• Reentrancy protection and safe external calls
• Event logging for transparency and monitoring

• Contract Address: 0x0746c9da88a54a60f534cfaefae0e72da73e7dc0ad3da449ffe60021622daa45
• Network: Starknet Sepolia
• Explorer: View on Starkscan

For production deployment:

1. Smart Contract: Deploy to Starknet Mainnet
2. Frontend: Deploy to Vercel, Netlify, or similar
3. IPFS: Configure production Pinata account
4. Monitoring: Set up blockchain monitoring and alerts

We welcome contributions! Please see our Contributing Guidelines for details.

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

This project is licensed under the MIT License - see the LICENSE file for details.

• Starknet Team for the amazing L2 infrastructure
• OpenZeppelin for security best practices
• Pinata for reliable IPFS services
• Cairo Community for development resources

⚡ Built with ❤️ on Starknet - Empowering patients, securing health data, revolutionizing healthcare. ⚡