Prescription Validator User Manual

The Prescription Validator verifies medication safety, checks insurance coverage, and confirms pharmacy availability through secure cross-chain oracle queries.

Overview

The Prescription Validator enables:

Drug interaction checking against medical history
Insurance coverage verification for medications
Cross-chain pharmacy availability confirmation
Automated prescription validation workflows

When to Use

Use the Prescription Validator for:

✅ New prescription writing
✅ Medication reconciliation
✅ Patient transfer to different facility
✅ Long-term medication refills

Do not use for:

❌ Emergency medications (use fast-track approval)
❌ Controlled substance initial prescribing (requires DEA forms)
❌ Clinical diagnosis support (not a clinical decision tool)

Data Privacy

What Data is Encrypted and Protected

{
    "patient_id": "patient_123",           // De-identified
    "encrypted_data": "fernet_ciphertext", // Medical history encrypted
    "ipfs_cid": "QmXx...",                 // Encrypted record reference
    "data_hash": "sha256_hash"             // Integrity hash only
}

What is NOT Exposed

❌ Patient's actual medical conditions
❌ Current medications
❌ Past prescriptions
❌ Drug allergies
❌ Any plaintext patient data

API Usage

Endpoint

POST /validate-prescription

Request Format

{
    "patient_data": {
        "patient_id": "PATIENT_ABC123",
        "encrypted_data": "gAAAAABlmZ...",
        "ipfs_cid": "QmV5koooi...",
        "data_hash": "a1b2c3d4..."
    },
    "drug_code": "DRUG001"
}

Drug Code Reference

Common prescription drugs:

Code	Drug Name	Category	Common Interactions
DRUG001	Warfarin	Anticoagulant	NSAIDs, Aspirin
DRUG002	Metoprolol	Beta-Blocker	Verapamil, Diltiazem
DRUG003	Lisinopril	ACE Inhibitor	Potassium supplements
DRUG004	Amoxicillin	Antibiotic	Oral contraceptives
DRUG005	Sertraline	SSRI	MAOIs, Tramadol
DRUG006	Metformin	Antidiabetic	Contrast dye
DRUG007	Ibuprofen	NSAID	Warfarin, ACE inhibitors
DRUG008	Omeprazole	PPI	Clopidogrel, Ketoconazole

Contact Oneliac support for additional drug codes.

Response Format

{
    "valid": true,
    "drug_code": "DRUG001",
    "interactions_checked": true,
    "zk_proof_verified": true,
    "cross_chain_oracle": "LayerZero confirmed: DRUG001 available on Ethereum bridge"
}

Response Fields

Field	Type	Description
`valid`	Boolean	Prescription is safe and covered
`drug_code`	String	Drug code validated
`interactions_checked`	Boolean	Drug interactions checked against medical history
`zk_proof_verified`	Boolean	Eligibility verified with ZK proof
`cross_chain_oracle`	String	Pharmacy availability confirmation

Validation Process

Step 1: Patient Eligibility Check

First, the validator verifies patient eligibility (same as Eligibility Checker):

Confirms patient has active insurance
Verifies coverage for the medication class
Checks for required prior authorizations

Step 2: Drug Interaction Analysis

Checks the drug against patient's medical history:

Current medications
Known allergies
Medical conditions
Drug contraindications

Step 3: Pharmacy Verification

Queries LayerZero oracle to confirm:

Drug availability in network pharmacies
Pricing information
Delivery options
Insurance acceptance

Step 4: Response

Returns validation result with:

Medication safety status
Coverage information
Pharmacy availability
Recommended action

Step-by-Step Usage

Step 1: Prepare Patient Data

Same as Eligibility Checker - encrypt medical history:

from cryptography.fernet import Fernet
import json
import hashlib

# Encryption
encryption_key = Fernet.generate_key()
cipher = Fernet(encryption_key)

patient_data = {
    "patient_id": "patient_456",
    "allergies": ["penicillin"],
    "current_meds": ["metoprolol", "lisinopril"],
    "conditions": ["hypertension", "arrhythmia"]
}

# Encrypt
encrypted_data = cipher.encrypt(
    json.dumps(patient_data).encode()
).decode()

# Hash for integrity
data_hash = hashlib.sha256(
    json.dumps(patient_data).encode()
).hexdigest()

print(f"Encrypted Data: {encrypted_data}")
print(f"Data Hash: {data_hash}")

Step 2: Call Validation API

import requests

api_url = "http://localhost:8000/validate-prescription"

payload = {
    "patient_data": {
        "patient_id": "PATIENT_456",
        "encrypted_data": encrypted_data,
        "ipfs_cid": "QmV5koooi...",
        "data_hash": data_hash
    },
    "drug_code": "DRUG001"  # Warfarin
}

response = requests.post(api_url, json=payload)
result = response.json()

print(f"Valid: {result['valid']}")
print(f"Interactions Checked: {result['interactions_checked']}")
print(f"Pharmacy Status: {result['cross_chain_oracle']}")

Step 3: Interpret Results

Scenario A: Medication is Safe and Covered

if result['valid']:
    print("✓ Prescription approved")
    print("✓ No dangerous interactions found")
    print(f"✓ Pharmacy available: {result['cross_chain_oracle']}")
    print("Action: Send to pharmacy")

Scenario B: Dangerous Interaction Detected

if not result['valid']:
    if "interaction" in result.get('reason', '').lower():
        print("✗ Dangerous drug interaction detected")
        print("Action: Review and modify medication")
    elif "coverage" in result.get('reason', '').lower():
        print("✗ Medication not covered by insurance")
        print("Action: Check prior authorization requirements")

Integration Examples

EHR Integration

def validate_prescription_in_ehr(
    patient_id: str,
    drug_code: str,
    encrypted_patient_data: str
):
    """Validate prescription before writing in EHR."""
    
    # Call validation API
    result = call_validation_api(
        patient_data=encrypted_patient_data,
        drug_code=drug_code
    )
    
    if result['valid']:
        # Enable prescription writing
        show_success_message(
            f"Prescription for {drug_code} is safe and covered"
        )
        return True
    else:
        # Block prescription, show warning
        show_error_dialog(
            title="Prescription Not Approved",
            message=f"Reason: {result['reason']}",
            options=["Modify", "Cancel", "Override (with note)"]
        )
        return False

Pharmacy System Integration

def send_validated_prescription_to_pharmacy(
    prescription_id: str,
    patient_id: str,
    drug_code: str,
    validation_result: dict
):
    """Send validated prescription to network pharmacy."""
    
    if not validation_result['valid']:
        raise ValueError("Cannot send invalid prescription to pharmacy")
    
    # Extract pharmacy info from oracle result
    pharmacy_info = parse_oracle_result(
        validation_result['cross_chain_oracle']
    )
    
    # Format for pharmacy system
    pharmacy_payload = {
        "prescription_id": prescription_id,
        "patient_id": patient_id,
        "drug_code": drug_code,
        "pharmacy": pharmacy_info['pharmacy_id'],
        "validation_hash": validation_result.get('validation_hash')
    }
    
    # Send to pharmacy
    response = requests.post(
        f"https://pharmacy-system.com/api/prescription",
        json=pharmacy_payload
    )
    
    return response.status_code == 200

Drug Interaction Rules

High-Risk Interactions (Blocked)

These combinations are automatically rejected:

Drug 1	Drug 2	Risk	Action
Warfarin	NSAID	Bleeding	Rejected
Methotrexate	NSAIDs	Kidney damage	Rejected
ACE Inhibitor	Potassium supplement	Hyperkalemia	Rejected
MAOI	SSRI	Serotonin syndrome	Rejected

Moderate-Risk Interactions (Require Monitoring)

Drug 1	Drug 2	Risk	Recommendation
Metoprolol	Verapamil	Bradycardia	Monitor heart rate
Lisinopril	NSAIDs	Reduced efficacy	Monitor BP
Warfarin	Antibiotics	Increased bleeding	Monitor INR
Sertraline	Tramadol	Serotonin syndrome	Use alternative analgesic

Allergy Checks

Automatically blocked if patient allergic:

Penicillin allergy → Block amoxicillin, ampicillin
Sulfa allergy → Block sulfamethoxazole, furosemide
NSAID allergy → Block ibuprofen, naproxen

Error Handling

Common Errors

Error 1: Patient Not Eligible

{
    "valid": false,
    "reason": "Patient not eligible for this medication",
    "drug_code": "DRUG001"
}

Solution: Check patient's insurance status. May need prior authorization.

Error 2: Drug Interaction Detected

{
    "valid": false,
    "reason": "Drug interaction detected with current medication Warfarin",
    "drug_code": "DRUG007"
}

Solution:

Review patient's current medications
Choose alternative medication
Contact prescriber if interaction expected

Error 3: Drug Not Found

{
    "valid": false,
    "reason": "Drug code DRUG999 not found in database",
    "drug_code": "DRUG999"
}

Solution: Verify drug code. Contact Oneliac support for new drugs.

Error 4: Pharmacy Network Error

{
    "valid": true,
    "reason": "Oracle returned incomplete data",
    "cross_chain_oracle": "Connection timeout to pharmacy network"
}

Solution: Retry request. System will still allow prescription but without pharmacy info.

Retry Logic

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
def call_validation_api_with_retry(payload):
    response = requests.post(
        "http://localhost:8000/validate-prescription",
        json=payload
    )
    response.raise_for_status()
    return response.json()

Performance Characteristics

Operation	Time
Patient eligibility check	100-300ms
Drug interaction analysis	50-150ms
Pharmacy oracle query	200-800ms
Total validation time	400-1300ms

Optimization: Cache eligibility results to reduce time for multiple drugs from same patient.

Testing

Test Case 1: Valid Prescription

test_payload = {
    "patient_data": {
        "patient_id": "TEST_VALID_001",
        "encrypted_data": "...",
        "ipfs_cid": "...",
        "data_hash": "..."
    },
    "drug_code": "DRUG003"  # Lisinopril (no interactions)
}

# Expected: valid=true, interactions_checked=true

Test Case 2: Interaction Detected

test_payload = {
    "patient_data": {
        "patient_id": "TEST_INTERACT_001",
        # Medical history includes NSAID use
        "encrypted_data": "...",
        "ipfs_cid": "...",
        "data_hash": "..."
    },
    "drug_code": "DRUG001"  # Warfarin (dangerous with NSAIDs)
}

# Expected: valid=false, reason contains "interaction"

Test Case 3: Allergy Check

test_payload = {
    "patient_data": {
        "patient_id": "TEST_ALLERGY_001",
        # Medical history includes penicillin allergy
        "encrypted_data": "...",
        "ipfs_cid": "...",
        "data_hash": "..."
    },
    "drug_code": "DRUG004"  # Amoxicillin (penicillin)
}

# Expected: valid=false, reason contains "allergy"

Audit Logging

Log all prescription validations for compliance:

import logging
import json

logging.basicConfig(
    filename='prescription_validations.log',
    level=logging.INFO,
    format='%(asctime)s - %(message)s'
)

def log_validation(patient_id, drug_code, result):
    """Log prescription validation for audit trail."""
    logging.info(json.dumps({
        "patient_id": patient_id,
        "drug_code": drug_code,
        "valid": result['valid'],
        "zk_proof_verified": result['zk_proof_verified'],
        "timestamp": datetime.utcnow().isoformat()
    }))

Compliance & Security

HIPAA: Patient medical data encrypted end-to-end
Drug Interaction Database: Based on FDA approved interactions
Cross-Chain Oracle: Pharmacy data verified on blockchain
Audit Trail: All validations recorded immutably

Best Practices

Always Validate: Never bypass validation for convenience
Review Overrides: Document any manual overrides
Monitor Interactions: Track if certain interactions are common
Update Databases: Regularly update drug interaction database
Patient Notification: Inform patient if interaction detected

Next Steps

Eligibility Checker - Verify insurance coverage
Federated Learning - Improve diagnosis models
API Reference - Full documentation
Integration Guide - Detailed setup

Support

Documentation: This guide
GitHub: https://github.com/orgs/Oneliac
Telegram: https://t.me/oneliac_bot
Website: https://www.oneliac.xyz

Overview​

When to Use​

Data Privacy​

What Data is Encrypted and Protected​

What is NOT Exposed​

API Usage​

Endpoint​

Request Format​

Drug Code Reference​

Response Format​

Response Fields​

Validation Process​

Step 1: Patient Eligibility Check​

Step 2: Drug Interaction Analysis​

Step 3: Pharmacy Verification​

Step 4: Response​

Step-by-Step Usage​

Step 1: Prepare Patient Data​

Step 2: Call Validation API​

Step 3: Interpret Results​

Scenario A: Medication is Safe and Covered​

Scenario B: Dangerous Interaction Detected​

Integration Examples​

EHR Integration​

Pharmacy System Integration​

Drug Interaction Rules​

High-Risk Interactions (Blocked)​

Moderate-Risk Interactions (Require Monitoring)​

Allergy Checks​

Error Handling​

Common Errors​

Error 1: Patient Not Eligible​

Error 2: Drug Interaction Detected​

Error 3: Drug Not Found​

Error 4: Pharmacy Network Error​

Retry Logic​

Performance Characteristics​

Testing​

Test Case 1: Valid Prescription​

Test Case 2: Interaction Detected​

Test Case 3: Allergy Check​

Audit Logging​

Compliance & Security​

Best Practices​

Next Steps​

Support​