diff --git a/src/algorithms/index.ts b/src/algorithms/index.ts
new file mode 100644
index 0000000..fc71b6f
--- /dev/null
+++ b/src/algorithms/index.ts
@@ -0,0 +1,94 @@
+// OTP Algorithm Registry
+// Central registry for all OTP algorithm versions
+
+import { OTPAlgorithm, OTPVersion, DEFAULT_OTP_VERSION, LATEST_OTP_VERSION, OTP_VERSION_LABELS, OTP_VERSION_DESCRIPTIONS } from './types';
+import otpV0Algorithm from './otp_v0';
+import otpV1Algorithm from './otp_v1';
+
+// Algorithm registry
+const algorithms: Map<OTPVersion, OTPAlgorithm> = new Map([
+    ['otp_v0', otpV0Algorithm],
+    ['otp_v1', otpV1Algorithm],
+]);
+
+/**
+ * Get an OTP algorithm by version
+ */
+export function getAlgorithm(version: OTPVersion): OTPAlgorithm {
+    const algorithm = algorithms.get(version);
+    if (!algorithm) {
+        console.warn(`Unknown OTP version: ${version}, falling back to ${DEFAULT_OTP_VERSION}`);
+        const defaultAlgorithm = algorithms.get(DEFAULT_OTP_VERSION);
+        if (!defaultAlgorithm) {
+            throw new Error(`Default OTP algorithm (${DEFAULT_OTP_VERSION}) is not registered`);
+        }
+        return defaultAlgorithm;
+    }
+    return algorithm;
+}
+
+/**
+ * Get all available OTP versions
+ */
+export function getAvailableVersions(): OTPVersion[] {
+    return Array.from(algorithms.keys());
+}
+
+/**
+ * Check if a version is valid
+ */
+export function isValidVersion(version: string): version is OTPVersion {
+    return algorithms.has(version as OTPVersion);
+}
+
+/**
+ * Encrypt a message using the specified OTP version
+ */
+export function encryptWithVersion(
+    message: string,
+    rawKey: string,
+    offset: number,
+    version: OTPVersion = DEFAULT_OTP_VERSION
+): string {
+    const algorithm = getAlgorithm(version);
+    const transformedKey = algorithm.transformKey(rawKey);
+    return algorithm.encrypt(message, transformedKey, offset);
+}
+
+/**
+ * Decrypt a message using the specified OTP version
+ */
+export function decryptWithVersion(
+    encrypted: string,
+    rawKey: string,
+    offset: number,
+    version: OTPVersion = DEFAULT_OTP_VERSION
+): string {
+    const algorithm = getAlgorithm(version);
+    const transformedKey = algorithm.transformKey(rawKey);
+    return algorithm.decrypt(encrypted, transformedKey, offset);
+}
+
+/**
+ * Transform a raw key using the specified OTP version
+ */
+export function transformKeyWithVersion(
+    rawKey: string,
+    version: OTPVersion = DEFAULT_OTP_VERSION
+): string {
+    const algorithm = getAlgorithm(version);
+    return algorithm.transformKey(rawKey);
+}
+
+// Re-export types and constants
+export {
+    OTPAlgorithm,
+    OTPVersion,
+    DEFAULT_OTP_VERSION,
+    LATEST_OTP_VERSION,
+    OTP_VERSION_LABELS,
+    OTP_VERSION_DESCRIPTIONS,
+};
+
+// Export individual algorithms
+export { otpV0Algorithm, otpV1Algorithm };
diff --git a/src/algorithms/otp_v0/index.ts b/src/algorithms/otp_v0/index.ts
new file mode 100644
index 0000000..e73d201
--- /dev/null
+++ b/src/algorithms/otp_v0/index.ts
@@ -0,0 +1,74 @@
+// OTP v0 Algorithm - Legacy Implementation
+// This is the original OTP algorithm with basic key transformation
+
+import { OTPAlgorithm, OTPVersion } from '../types';
+
+/**
+ * Simple XOR-based encryption using key stream
+ */
+function xorEncrypt(message: string, key: string, offset: number): string {
+    const result: number[] = [];
+    const keyLength = key.length;
+    
+    if (keyLength === 0) {
+        return message;
+    }
+    
+    for (let i = 0; i < message.length; i++) {
+        const messageCharCode = message.charCodeAt(i);
+        const keyIndex = (offset + i) % keyLength;
+        const keyCharCode = key.charCodeAt(keyIndex);
+        result.push(messageCharCode ^ keyCharCode);
+    }
+    
+    // Convert to base64 for safe transmission
+    return btoa(String.fromCharCode(...result));
+}
+
+/**
+ * Simple XOR-based decryption using key stream
+ */
+function xorDecrypt(encrypted: string, key: string, offset: number): string {
+    const keyLength = key.length;
+    
+    if (keyLength === 0) {
+        return encrypted;
+    }
+    
+    try {
+        // Decode from base64
+        const decoded = atob(encrypted);
+        const result: number[] = [];
+        
+        for (let i = 0; i < decoded.length; i++) {
+            const encryptedCharCode = decoded.charCodeAt(i);
+            const keyIndex = (offset + i) % keyLength;
+            const keyCharCode = key.charCodeAt(keyIndex);
+            result.push(encryptedCharCode ^ keyCharCode);
+        }
+        
+        return String.fromCharCode(...result);
+    } catch {
+        // If decryption fails, return an empty string to avoid leaking encryption format info
+        console.warn('Decryption failed in OTP v0');
+        return '';
+    }
+}
+
+/**
+ * Basic key transformation - just returns the key as-is
+ */
+function transformKey(rawKey: string): string {
+    return rawKey;
+}
+
+const otpV0Algorithm: OTPAlgorithm = {
+    version: 'otp_v0' as OTPVersion,
+    name: 'OTP v0 (Legacy)',
+    description: 'Original OTP encryption with basic key transformation',
+    transformKey,
+    encrypt: xorEncrypt,
+    decrypt: xorDecrypt,
+};
+
+export default otpV0Algorithm;
diff --git a/src/algorithms/otp_v1/index.ts b/src/algorithms/otp_v1/index.ts
new file mode 100644
index 0000000..8bb03bf
--- /dev/null
+++ b/src/algorithms/otp_v1/index.ts
@@ -0,0 +1,142 @@
+// OTP v1 Algorithm - Enhanced Implementation
+// This is the enhanced OTP algorithm with improved key expansion and security
+
+import { OTPAlgorithm, OTPVersion } from '../types';
+
+/**
+ * System message threshold - keys larger than this trigger a system message
+ */
+export const SYSTEM_MESSAGE_KEY_THRESHOLD = 256;
+
+/**
+ * Simple hash function for key expansion
+ * Uses a basic mixing algorithm to expand short keys
+ */
+function hashExpand(input: string, targetLength: number): string {
+    if (input.length === 0) {
+        return '';
+    }
+    
+    // Start with the input repeated to at least target length
+    let expanded = input;
+    while (expanded.length < targetLength) {
+        expanded += input;
+    }
+    
+    // Mix the bytes using a simple algorithm
+    const result: number[] = [];
+    let accumulator = 0;
+    
+    for (let i = 0; i < targetLength; i++) {
+        const charCode = expanded.charCodeAt(i % expanded.length);
+        accumulator = (accumulator + charCode * 31 + i * 17) % 256;
+        result.push(accumulator ^ charCode);
+    }
+    
+    return String.fromCharCode(...result);
+}
+
+/**
+ * Enhanced key transformation with expansion
+ * Expands short keys to improve security
+ */
+function transformKey(rawKey: string): string {
+    if (rawKey.length === 0) {
+        return '';
+    }
+    
+    // Minimum expanded key length for v1
+    const minLength = Math.max(rawKey.length * 4, 1024);
+    return hashExpand(rawKey, minLength);
+}
+
+/**
+ * Enhanced XOR encryption with key stream
+ */
+function encrypt(message: string, key: string, offset: number): string {
+    const result: number[] = [];
+    const keyLength = key.length;
+    
+    if (keyLength === 0) {
+        return message;
+    }
+    
+    for (let i = 0; i < message.length; i++) {
+        const messageCharCode = message.charCodeAt(i);
+        // Use modular arithmetic with offset for key position
+        const keyIndex = (offset + i) % keyLength;
+        const keyCharCode = key.charCodeAt(keyIndex);
+        // Additional mixing step for v1
+        const mixedKey = (keyCharCode + i) % 256;
+        result.push(messageCharCode ^ mixedKey);
+    }
+    
+    // Convert to base64 for safe transmission
+    return btoa(String.fromCharCode(...result));
+}
+
+/**
+ * Enhanced XOR decryption with key stream
+ */
+function decrypt(encrypted: string, key: string, offset: number): string {
+    const keyLength = key.length;
+    
+    if (keyLength === 0) {
+        return encrypted;
+    }
+    
+    try {
+        // Decode from base64
+        const decoded = atob(encrypted);
+        const result: number[] = [];
+        
+        for (let i = 0; i < decoded.length; i++) {
+            const encryptedCharCode = decoded.charCodeAt(i);
+            const keyIndex = (offset + i) % keyLength;
+            const keyCharCode = key.charCodeAt(keyIndex);
+            // Same mixing step as encryption for v1
+            const mixedKey = (keyCharCode + i) % 256;
+            result.push(encryptedCharCode ^ mixedKey);
+        }
+        
+        return String.fromCharCode(...result);
+    } catch {
+        // If decryption fails, return an empty string to avoid leaking encryption format info
+        console.warn('Decryption failed in OTP v1');
+        return '';
+    }
+}
+
+/**
+ * Check if key length exceeds the system message threshold
+ */
+export function shouldShowSystemMessage(keyLength: number): boolean {
+    return keyLength > SYSTEM_MESSAGE_KEY_THRESHOLD;
+}
+
+/**
+ * Generate system message for large keys
+ * @param keyLength Length of the encryption key
+ * @param messageGenerator Optional custom message generator function
+ */
+export function generateLargeKeySystemMessage(
+    keyLength: number, 
+    messageGenerator?: (keyLength: number) => string
+): string {
+    if (messageGenerator) {
+        return messageGenerator(keyLength);
+    }
+    // Default message (Turkish) - use i18n in calling code for proper localization
+    return `<system>Şifreleme anahtarı ${keyLength} karakter uzunluğunda. Bu uzun bir anahtar olduğundan, güvenlik artırılmış durumda.</system>`;
+}
+
+const otpV1Algorithm: OTPAlgorithm = {
+    version: 'otp_v1' as OTPVersion,
+    name: 'OTP v1 (Enhanced)',
+    description: 'Enhanced OTP encryption with improved key expansion and security',
+    transformKey,
+    encrypt,
+    decrypt,
+};
+
+export default otpV1Algorithm;
diff --git a/src/algorithms/types.ts b/src/algorithms/types.ts
new file mode 100644
index 0000000..bb5b931
--- /dev/null
+++ b/src/algorithms/types.ts
@@ -0,0 +1,71 @@
+// OTP Algorithm Type Definitions
+
+/**
+ * Supported OTP versions
+ */
+export type OTPVersion = 'otp_v0' | 'otp_v1';
+
+/**
+ * Default OTP version for new DMs
+ */
+export const DEFAULT_OTP_VERSION: OTPVersion = 'otp_v1';
+
+/**
+ * Latest OTP version available
+ */
+export const LATEST_OTP_VERSION: OTPVersion = 'otp_v1';
+
+/**
+ * Human-readable labels for OTP versions
+ */
+export const OTP_VERSION_LABELS: Record<OTPVersion, string> = {
+    otp_v0: 'OTP v0 (Legacy)',
+    otp_v1: 'OTP v1 (Enhanced)',
+};
+
+/**
+ * Descriptions for OTP versions
+ */
+export const OTP_VERSION_DESCRIPTIONS: Record<OTPVersion, string> = {
+    otp_v0: 'Original OTP encryption with basic key transformation',
+    otp_v1: 'Enhanced OTP encryption with improved key expansion and security',
+};
+
+/**
+ * Interface for OTP algorithm implementations
+ */
+export interface OTPAlgorithm {
+    /** Version identifier */
+    version: OTPVersion;
+    
+    /** Display name */
+    name: string;
+    
+    /** Description of the algorithm */
+    description: string;
+    
+    /**
+     * Transform a raw key into the algorithm's internal format
+     * @param rawKey The original key provided by user
+     * @returns Transformed key ready for encryption/decryption
+     */
+    transformKey(rawKey: string): string;
+    
+    /**
+     * Encrypt a message using the transformed key
+     * @param message Plaintext message to encrypt
+     * @param key Transformed key (output of transformKey)
+     * @param offset Current offset in the key stream
+     * @returns Encrypted message
+     */
+    encrypt(message: string, key: string, offset: number): string;
+    
+    /**
+     * Decrypt a message using the transformed key
+     * @param encrypted Encrypted message
+     * @param key Transformed key (output of transformKey)
+     * @param offset Current offset in the key stream
+     * @returns Decrypted plaintext message
+     */
+    decrypt(encrypted: string, key: string, offset: number): string;
+}
diff --git a/src/i18n/index.ts b/src/i18n/index.ts
new file mode 100644
index 0000000..db81620
--- /dev/null
+++ b/src/i18n/index.ts
@@ -0,0 +1,3 @@
+// i18n Index
+export { translations, t, setLanguage, getLanguage, stripSystemTags } from './translations';
+export type { Language, TranslationKey } from './translations';
diff --git a/src/i18n/translations.ts b/src/i18n/translations.ts
new file mode 100644
index 0000000..b29a1c1
--- /dev/null
+++ b/src/i18n/translations.ts
@@ -0,0 +1,95 @@
+// i18n Translations
+// Translation strings for internationalization
+
+export const translations = {
+    tr: {
+        // System messages
+        largeKeySystemMessage: (keyLength: number) => 
+            `<system>Şifreleme anahtarı ${keyLength} karakter uzunluğunda. Bu uzun bir anahtar olduğundan, güvenlik artırılmış durumda.</system>`,
+        
+        // Encryption status
+        encryptionDisabled: 'Şifreleme devre dışı',
+        encryptedWith: (algorithmName: string) => `${algorithmName} ile şifreli`,
+        
+        // UI labels
+        advancedSettings: 'Gelişmiş Ayarlar',
+        encryptionType: 'Şifreleme Türü',
+        encryptionTypeDescription: 'Mesajlarınız için kullanılacak OTP şifreleme sürümünü seçin.',
+        encryptionKey: 'Şifreleme Anahtarı',
+        encryptionKeyDescription: (threshold: number) => 
+            `Mesajları şifrelemek için kullanılacak anahtar. ${threshold} karakterden uzun anahtarlar için sistem bildirimi gösterilir.`,
+        keyPlaceholder: 'Şifreleme anahtarını girin...',
+        keyLength: (length: number) => `Anahtar uzunluğu: ${length} karakter`,
+        largeKeyBadge: 'Büyük Anahtar',
+        defaultBadge: 'Varsayılan',
+        cancel: 'İptal',
+        save: 'Kaydet',
+        back: 'Geri',
+        send: 'Gönder',
+        messagePlaceholder: 'Mesaj yazın...',
+    },
+    en: {
+        // System messages
+        largeKeySystemMessage: (keyLength: number) => 
+            `<system>Encryption key is ${keyLength} characters long. Security is enhanced due to large key size.</system>`,
+        
+        // Encryption status
+        encryptionDisabled: 'Encryption disabled',
+        encryptedWith: (algorithmName: string) => `Encrypted with ${algorithmName}`,
+        
+        // UI labels
+        advancedSettings: 'Advanced Settings',
+        encryptionType: 'Encryption Type',
+        encryptionTypeDescription: 'Select the OTP encryption version for your messages.',
+        encryptionKey: 'Encryption Key',
+        encryptionKeyDescription: (threshold: number) => 
+            `Key used for message encryption. System notification shown for keys longer than ${threshold} characters.`,
+        keyPlaceholder: 'Enter encryption key...',
+        keyLength: (length: number) => `Key length: ${length} characters`,
+        largeKeyBadge: 'Large Key',
+        defaultBadge: 'Default',
+        cancel: 'Cancel',
+        save: 'Save',
+        back: 'Back',
+        send: 'Send',
+        messagePlaceholder: 'Type a message...',
+    },
+};
+
+export type Language = keyof typeof translations;
+export type TranslationKey = keyof typeof translations.tr;
+
+/**
+ * Current language setting
+ */
+let currentLanguage: Language = 'tr';
+
+/**
+ * Set the current language
+ */
+export function setLanguage(lang: Language): void {
+    currentLanguage = lang;
+}
+
+/**
+ * Get the current language
+ */
+export function getLanguage(): Language {
+    return currentLanguage;
+}
+
+/**
+ * Get translations for the current language
+ */
+export function t(): typeof translations.tr {
+    return translations[currentLanguage];
+}
+
+/**
+ * Utility to remove system message tags
+ */
+export function stripSystemTags(message: string): string {
+    return message.replace(/<\/?system>/g, '');
+}
+
+export default translations;
diff --git a/src/index.ts b/src/index.ts
new file mode 100644
index 0000000..6b01aad
--- /dev/null
+++ b/src/index.ts
@@ -0,0 +1,17 @@
+// Main Entry Point
+// Export all modules for the OTP versioning system for DM
+
+// Algorithms
+export * from './algorithms';
+
+// Stores
+export * from './stores';
+
+// Services
+export * from './services';
+
+// i18n
+export * from './i18n';
+
+// Screens
+export { DMChatScreen } from './screens/dm';
diff --git a/src/package.json b/src/package.json
new file mode 100644
index 0000000..24239ec
--- /dev/null
+++ b/src/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "pattern-analyzer-dm",
+  "version": "1.0.0",
+  "description": "OTP versioning system for Direct Messages",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts,.tsx"
+  },
+  "dependencies": {
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0"
+  }
+}
diff --git a/src/screens/dm/DMChatScreen.tsx b/src/screens/dm/DMChatScreen.tsx
new file mode 100644
index 0000000..4fcce0a
--- /dev/null
+++ b/src/screens/dm/DMChatScreen.tsx
@@ -0,0 +1,571 @@
+// DM Chat Screen
+// Direct Message chat screen with OTP versioning support and advanced settings
+
+import React, { useState, useCallback, useMemo } from 'react';
+import { 
+    OTPVersion, 
+    DEFAULT_OTP_VERSION, 
+    OTP_VERSION_LABELS, 
+    OTP_VERSION_DESCRIPTIONS,
+    getAvailableVersions 
+} from '../../algorithms';
+import { dmService, DMMessage } from '../../services/dmService';
+import { t, stripSystemTags } from '../../i18n';
+
+/**
+ * Props for DMChatScreen component
+ */
+interface DMChatScreenProps {
+    conversationId: string;
+    participantName: string;
+    onBack?: () => void;
+}
+
+/**
+ * Props for Advanced Settings Modal
+ */
+interface AdvancedSettingsProps {
+    isOpen: boolean;
+    onClose: () => void;
+    conversationId: string;
+    currentVersion: OTPVersion;
+    currentKey: string;
+    onVersionChange: (version: OTPVersion) => void;
+    onKeyChange: (key: string) => void;
+}
+
+/**
+ * Advanced Settings Modal Component
+ */
+const AdvancedSettings: React.FC<AdvancedSettingsProps> = ({
+    isOpen,
+    onClose,
+    conversationId,
+    currentVersion,
+    currentKey,
+    onVersionChange,
+    onKeyChange,
+}) => {
+    const [selectedVersion, setSelectedVersion] = useState<OTPVersion>(currentVersion);
+    const [encryptionKey, setEncryptionKey] = useState(currentKey);
+    const availableVersions = useMemo(() => getAvailableVersions(), []);
+
+    const handleSave = useCallback(() => {
+        if (selectedVersion !== currentVersion) {
+            onVersionChange(selectedVersion);
+        }
+        if (encryptionKey !== currentKey) {
+            onKeyChange(encryptionKey);
+        }
+        onClose();
+    }, [selectedVersion, currentVersion, encryptionKey, currentKey, onVersionChange, onKeyChange, onClose]);
+
+    if (!isOpen) return null;
+
+    const translations = t();
+
+    return (
+        <div className="advanced-settings-modal">
+            <div className="modal-overlay" onClick={onClose} />
+            <div className="modal-content">
+                <h2>{translations.advancedSettings}</h2>
+                
+                <div className="settings-section">
+                    <h3>{translations.encryptionType}</h3>
+                    <p className="section-description">
+                        {translations.encryptionTypeDescription}
+                    </p>
+                    
+                    <div className="version-selector">
+                        {availableVersions.map((version) => (
+                            <div 
+                                key={version}
+                                className={`version-option ${selectedVersion === version ? 'selected' : ''}`}
+                                onClick={() => setSelectedVersion(version)}
+                            >
+                                <div className="version-header">
+                                    <input
+                                        type="radio"
+                                        name="otpVersion"
+                                        checked={selectedVersion === version}
+                                        onChange={() => setSelectedVersion(version)}
+                                    />
+                                    <span className="version-label">{OTP_VERSION_LABELS[version]}</span>
+                                    {version === DEFAULT_OTP_VERSION && (
+                                        <span className="default-badge">{translations.defaultBadge}</span>
+                                    )}
+                                </div>
+                                <p className="version-description">{OTP_VERSION_DESCRIPTIONS[version]}</p>
+                            </div>
+                        ))}
+                    </div>
+                </div>
+
+                <div className="settings-section">
+                    <h3>{translations.encryptionKey}</h3>
+                    <p className="section-description">
+                        {translations.encryptionKeyDescription(dmService.getKeyThreshold())}
+                    </p>
+                    
+                    <div className="key-input-container">
+                        <textarea
+                            className="key-input"
+                            value={encryptionKey}
+                            onChange={(e) => setEncryptionKey(e.target.value)}
+                            placeholder={translations.keyPlaceholder}
+                            rows={3}
+                        />
+                        <div className="key-info">
+                            <span>{translations.keyLength(encryptionKey.length)}</span>
+                            {dmService.isLargeKey(encryptionKey.length) && (
+                                <span className="large-key-badge">{translations.largeKeyBadge}</span>
+                            )}
+                        </div>
+                    </div>
+                </div>
+
+                <div className="modal-actions">
+                    <button className="cancel-button" onClick={onClose}>
+                        {translations.cancel}
+                    </button>
+                    <button className="save-button" onClick={handleSave}>
+                        {translations.save}
+                    </button>
+                </div>
+            </div>
+
+            <style>{`
+                .advanced-settings-modal {
+                    position: fixed;
+                    top: 0;
+                    left: 0;
+                    right: 0;
+                    bottom: 0;
+                    z-index: 1000;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                }
+
+                .modal-overlay {
+                    position: absolute;
+                    top: 0;
+                    left: 0;
+                    right: 0;
+                    bottom: 0;
+                    background: rgba(0, 0, 0, 0.5);
+                }
+
+                .modal-content {
+                    position: relative;
+                    background: white;
+                    border-radius: 12px;
+                    padding: 24px;
+                    max-width: 500px;
+                    width: 90%;
+                    max-height: 90vh;
+                    overflow-y: auto;
+                    box-shadow: 0 4px 24px rgba(0, 0, 0, 0.2);
+                }
+
+                .modal-content h2 {
+                    margin: 0 0 20px;
+                    font-size: 20px;
+                    color: #1a1a1a;
+                }
+
+                .settings-section {
+                    margin-bottom: 24px;
+                }
+
+                .settings-section h3 {
+                    margin: 0 0 8px;
+                    font-size: 16px;
+                    color: #333;
+                }
+
+                .section-description {
+                    margin: 0 0 12px;
+                    font-size: 14px;
+                    color: #666;
+                }
+
+                .version-selector {
+                    display: flex;
+                    flex-direction: column;
+                    gap: 12px;
+                }
+
+                .version-option {
+                    padding: 12px;
+                    border: 2px solid #e0e0e0;
+                    border-radius: 8px;
+                    cursor: pointer;
+                    transition: all 0.2s;
+                }
+
+                .version-option:hover {
+                    border-color: #0066cc;
+                }
+
+                .version-option.selected {
+                    border-color: #0066cc;
+                    background: #f0f7ff;
+                }
+
+                .version-header {
+                    display: flex;
+                    align-items: center;
+                    gap: 8px;
+                    margin-bottom: 4px;
+                }
+
+                .version-label {
+                    font-weight: 600;
+                    color: #1a1a1a;
+                }
+
+                .default-badge {
+                    background: #0066cc;
+                    color: white;
+                    padding: 2px 8px;
+                    border-radius: 12px;
+                    font-size: 12px;
+                }
+
+                .version-description {
+                    margin: 0;
+                    font-size: 13px;
+                    color: #666;
+                    margin-left: 24px;
+                }
+
+                .key-input-container {
+                    display: flex;
+                    flex-direction: column;
+                    gap: 8px;
+                }
+
+                .key-input {
+                    width: 100%;
+                    padding: 12px;
+                    border: 2px solid #e0e0e0;
+                    border-radius: 8px;
+                    font-family: monospace;
+                    font-size: 14px;
+                    resize: vertical;
+                }
+
+                .key-input:focus {
+                    outline: none;
+                    border-color: #0066cc;
+                }
+
+                .key-info {
+                    display: flex;
+                    align-items: center;
+                    gap: 12px;
+                    font-size: 13px;
+                    color: #666;
+                }
+
+                .large-key-badge {
+                    background: #28a745;
+                    color: white;
+                    padding: 2px 8px;
+                    border-radius: 12px;
+                    font-size: 12px;
+                }
+
+                .modal-actions {
+                    display: flex;
+                    justify-content: flex-end;
+                    gap: 12px;
+                    margin-top: 24px;
+                }
+
+                .cancel-button {
+                    padding: 10px 20px;
+                    border: 1px solid #ddd;
+                    border-radius: 8px;
+                    background: white;
+                    cursor: pointer;
+                    font-size: 14px;
+                }
+
+                .cancel-button:hover {
+                    background: #f5f5f5;
+                }
+
+                .save-button {
+                    padding: 10px 20px;
+                    border: none;
+                    border-radius: 8px;
+                    background: #0066cc;
+                    color: white;
+                    cursor: pointer;
+                    font-size: 14px;
+                }
+
+                .save-button:hover {
+                    background: #0052a3;
+                }
+            `}</style>
+        </div>
+    );
+};
+
+/**
+ * DM Chat Screen Component
+ */
+const DMChatScreen: React.FC<DMChatScreenProps> = ({
+    conversationId,
+    participantName,
+    onBack,
+}) => {
+    const [messages, setMessages] = useState<DMMessage[]>([]);
+    const [inputText, setInputText] = useState('');
+    const [showAdvancedSettings, setShowAdvancedSettings] = useState(false);
+    
+    // Get current encryption config
+    const config = dmService.getConfig(conversationId);
+    const currentVersion = config?.otpVersion ?? DEFAULT_OTP_VERSION;
+    const currentKey = config?.rawKey ?? '';
+    const encryptionStatus = dmService.getEncryptionStatus(conversationId);
+
+    const handleSendMessage = useCallback(() => {
+        if (!inputText.trim()) return;
+
+        const encrypted = dmService.encryptMessage(conversationId, inputText);
+        
+        const newMessage: DMMessage = {
+            id: `msg-${Date.now()}`,
+            senderId: 'self',
+            content: inputText,
+            encryptedContent: encrypted,
+            timestamp: Date.now(),
+        };
+
+        setMessages(prev => [...prev, newMessage]);
+        setInputText('');
+    }, [conversationId, inputText]);
+
+    const handleVersionChange = useCallback((version: OTPVersion) => {
+        dmService.updateOTPVersion(conversationId, version);
+    }, [conversationId]);
+
+    const handleKeyChange = useCallback((key: string) => {
+        const systemMessage = dmService.updateKey(conversationId, key);
+        if (systemMessage) {
+            setMessages(prev => [...prev, systemMessage]);
+        }
+    }, [conversationId]);
+
+    const translations = t();
+
+    return (
+        <div className="dm-chat-screen">
+            <header className="chat-header">
+                {onBack && (
+                    <button className="back-button" onClick={onBack}>
+                        ← {translations.back}
+                    </button>
+                )}
+                <div className="header-info">
+                    <h1>{participantName}</h1>
+                    <span className="encryption-status">{encryptionStatus}</span>
+                </div>
+                <button 
+                    className="settings-button"
+                    onClick={() => setShowAdvancedSettings(true)}
+                >
+                    ⚙️ {translations.advancedSettings}
+                </button>
+            </header>
+
+            <div className="messages-container">
+                {messages.map(message => (
+                    <div 
+                        key={message.id} 
+                        className={`message ${message.isSystemMessage ? 'system' : message.senderId === 'self' ? 'sent' : 'received'}`}
+                    >
+                        {message.isSystemMessage ? (
+                            <div className="system-message">
+                                {stripSystemTags(message.content)}
+                            </div>
+                        ) : (
+                            <div className="message-content">{message.content}</div>
+                        )}
+                        <span className="message-time">
+                            {new Date(message.timestamp).toLocaleTimeString()}
+                        </span>
+                    </div>
+                ))}
+            </div>
+
+            <div className="input-container">
+                <input
+                    type="text"
+                    value={inputText}
+                    onChange={(e) => setInputText(e.target.value)}
+                    onKeyPress={(e) => e.key === 'Enter' && handleSendMessage()}
+                    placeholder={translations.messagePlaceholder}
+                    className="message-input"
+                />
+                <button onClick={handleSendMessage} className="send-button">
+                    {translations.send}
+                </button>
+            </div>
+
+            <AdvancedSettings
+                isOpen={showAdvancedSettings}
+                onClose={() => setShowAdvancedSettings(false)}
+                conversationId={conversationId}
+                currentVersion={currentVersion}
+                currentKey={currentKey}
+                onVersionChange={handleVersionChange}
+                onKeyChange={handleKeyChange}
+            />
+
+            <style>{`
+                .dm-chat-screen {
+                    display: flex;
+                    flex-direction: column;
+                    height: 100vh;
+                    background: #f5f5f5;
+                }
+
+                .chat-header {
+                    display: flex;
+                    align-items: center;
+                    padding: 16px;
+                    background: white;
+                    border-bottom: 1px solid #e0e0e0;
+                    gap: 16px;
+                }
+
+                .back-button {
+                    padding: 8px 12px;
+                    border: none;
+                    background: transparent;
+                    cursor: pointer;
+                    font-size: 16px;
+                }
+
+                .header-info {
+                    flex: 1;
+                }
+
+                .header-info h1 {
+                    margin: 0;
+                    font-size: 18px;
+                    color: #1a1a1a;
+                }
+
+                .encryption-status {
+                    font-size: 12px;
+                    color: #666;
+                }
+
+                .settings-button {
+                    padding: 8px 16px;
+                    border: 1px solid #ddd;
+                    border-radius: 8px;
+                    background: white;
+                    cursor: pointer;
+                    font-size: 14px;
+                }
+
+                .settings-button:hover {
+                    background: #f5f5f5;
+                }
+
+                .messages-container {
+                    flex: 1;
+                    overflow-y: auto;
+                    padding: 16px;
+                    display: flex;
+                    flex-direction: column;
+                    gap: 8px;
+                }
+
+                .message {
+                    max-width: 70%;
+                    padding: 12px;
+                    border-radius: 12px;
+                }
+
+                .message.sent {
+                    align-self: flex-end;
+                    background: #0066cc;
+                    color: white;
+                }
+
+                .message.received {
+                    align-self: flex-start;
+                    background: white;
+                    border: 1px solid #e0e0e0;
+                }
+
+                .message.system {
+                    align-self: center;
+                    background: #fff3cd;
+                    border: 1px solid #ffc107;
+                    max-width: 90%;
+                }
+
+                .system-message {
+                    font-size: 13px;
+                    color: #856404;
+                    text-align: center;
+                }
+
+                .message-content {
+                    margin-bottom: 4px;
+                }
+
+                .message-time {
+                    font-size: 11px;
+                    opacity: 0.7;
+                }
+
+                .input-container {
+                    display: flex;
+                    padding: 16px;
+                    background: white;
+                    border-top: 1px solid #e0e0e0;
+                    gap: 12px;
+                }
+
+                .message-input {
+                    flex: 1;
+                    padding: 12px;
+                    border: 1px solid #ddd;
+                    border-radius: 24px;
+                    font-size: 14px;
+                }
+
+                .message-input:focus {
+                    outline: none;
+                    border-color: #0066cc;
+                }
+
+                .send-button {
+                    padding: 12px 24px;
+                    border: none;
+                    border-radius: 24px;
+                    background: #0066cc;
+                    color: white;
+                    cursor: pointer;
+                    font-size: 14px;
+                }
+
+                .send-button:hover {
+                    background: #0052a3;
+                }
+            `}</style>
+        </div>
+    );
+};
+
+export default DMChatScreen;
diff --git a/src/screens/dm/index.ts b/src/screens/dm/index.ts
new file mode 100644
index 0000000..110fd03
--- /dev/null
+++ b/src/screens/dm/index.ts
@@ -0,0 +1,4 @@
+// DM Screens Index
+// Export all DM-related screens
+
+export { default as DMChatScreen } from './DMChatScreen';
diff --git a/src/services/DMHistoryService.ts b/src/services/DMHistoryService.ts
new file mode 100644
index 0000000..553cc52
--- /dev/null
+++ b/src/services/DMHistoryService.ts
@@ -0,0 +1,179 @@
+// DM History Service
+// Service for managing DM conversation history with OTP versioning
+
+import { OTPVersion, DEFAULT_OTP_VERSION } from '../algorithms/types';
+
+/**
+ * DM conversation history entry
+ */
+export interface DMHistoryEntry {
+    conversationId: string;
+    participantId: string;
+    participantName: string;
+    otpVersion: OTPVersion;
+    lastMessagePreview: string;
+    lastMessageTimestamp: number;
+    unreadCount: number;
+    hasEncryption: boolean;
+}
+
+/**
+ * Storage key for DM history
+ */
+const DM_HISTORY_STORAGE_KEY = 'dm_history';
+
+/**
+ * DM History Service class
+ * Manages conversation history with persistence
+ */
+class DMHistoryService {
+    private history: Map<string, DMHistoryEntry> = new Map();
+    private initialized: boolean = false;
+
+    /**
+     * Initialize the history service by loading from storage
+     */
+    initialize(): void {
+        if (this.initialized) return;
+
+        try {
+            const stored = localStorage.getItem(DM_HISTORY_STORAGE_KEY);
+            if (stored) {
+                const parsed = JSON.parse(stored) as DMHistoryEntry[];
+                parsed.forEach(entry => {
+                    this.history.set(entry.conversationId, entry);
+                });
+            }
+        } catch (error) {
+            console.error('Failed to load DM history:', error);
+        }
+
+        this.initialized = true;
+    }
+
+    /**
+     * Save history to storage
+     */
+    private saveToStorage(): void {
+        try {
+            const entries = Array.from(this.history.values());
+            localStorage.setItem(DM_HISTORY_STORAGE_KEY, JSON.stringify(entries));
+        } catch (error) {
+            console.error('Failed to save DM history:', error);
+        }
+    }
+
+    /**
+     * Add or update a conversation in history
+     * @param entry History entry to add/update
+     */
+    addOrUpdate(entry: Partial<DMHistoryEntry> & { conversationId: string }): void {
+        const existing = this.history.get(entry.conversationId);
+        
+        const updated: DMHistoryEntry = {
+            conversationId: entry.conversationId,
+            participantId: entry.participantId ?? existing?.participantId ?? '',
+            participantName: entry.participantName ?? existing?.participantName ?? 'Unknown',
+            otpVersion: entry.otpVersion ?? existing?.otpVersion ?? DEFAULT_OTP_VERSION,
+            lastMessagePreview: entry.lastMessagePreview ?? existing?.lastMessagePreview ?? '',
+            lastMessageTimestamp: entry.lastMessageTimestamp ?? existing?.lastMessageTimestamp ?? Date.now(),
+            unreadCount: entry.unreadCount ?? existing?.unreadCount ?? 0,
+            hasEncryption: entry.hasEncryption ?? existing?.hasEncryption ?? false,
+        };
+
+        this.history.set(entry.conversationId, updated);
+        this.saveToStorage();
+    }
+
+    /**
+     * Update OTP version for a conversation
+     * @param conversationId Conversation ID
+     * @param otpVersion New OTP version
+     */
+    updateOTPVersion(conversationId: string, otpVersion: OTPVersion): void {
+        const existing = this.history.get(conversationId);
+        if (existing) {
+            existing.otpVersion = otpVersion;
+            this.saveToStorage();
+        }
+    }
+
+    /**
+     * Get a conversation from history
+     * @param conversationId Conversation ID
+     * @returns History entry or undefined
+     */
+    get(conversationId: string): DMHistoryEntry | undefined {
+        return this.history.get(conversationId);
+    }
+
+    /**
+     * Get all conversations sorted by last message time
+     * @returns Array of history entries
+     */
+    getAll(): DMHistoryEntry[] {
+        return Array.from(this.history.values())
+            .sort((a, b) => b.lastMessageTimestamp - a.lastMessageTimestamp);
+    }
+
+    /**
+     * Get conversations with unread messages
+     * @returns Array of entries with unread messages
+     */
+    getUnread(): DMHistoryEntry[] {
+        return this.getAll().filter(entry => entry.unreadCount > 0);
+    }
+
+    /**
+     * Mark a conversation as read
+     * @param conversationId Conversation ID
+     */
+    markAsRead(conversationId: string): void {
+        const entry = this.history.get(conversationId);
+        if (entry) {
+            entry.unreadCount = 0;
+            this.saveToStorage();
+        }
+    }
+
+    /**
+     * Increment unread count for a conversation
+     * @param conversationId Conversation ID
+     */
+    incrementUnread(conversationId: string): void {
+        const entry = this.history.get(conversationId);
+        if (entry) {
+            entry.unreadCount += 1;
+            this.saveToStorage();
+        }
+    }
+
+    /**
+     * Remove a conversation from history
+     * @param conversationId Conversation ID
+     */
+    remove(conversationId: string): void {
+        this.history.delete(conversationId);
+        this.saveToStorage();
+    }
+
+    /**
+     * Clear all history
+     */
+    clear(): void {
+        this.history.clear();
+        this.saveToStorage();
+    }
+
+    /**
+     * Get total unread count across all conversations
+     * @returns Total unread count
+     */
+    getTotalUnreadCount(): number {
+        return Array.from(this.history.values())
+            .reduce((sum, entry) => sum + entry.unreadCount, 0);
+    }
+}
+
+// Export singleton instance (using only named export for consistency)
+export const dmHistoryService = new DMHistoryService();
diff --git a/src/services/dmService.ts b/src/services/dmService.ts
new file mode 100644
index 0000000..c927cc1
--- /dev/null
+++ b/src/services/dmService.ts
@@ -0,0 +1,244 @@
+// DM Service
+// Service for handling Direct Message encryption and decryption with OTP versioning
+
+import { 
+    encryptWithVersion, 
+    decryptWithVersion, 
+    OTPVersion, 
+    DEFAULT_OTP_VERSION,
+    getAlgorithm 
+} from '../algorithms';
+import { dmOtpStore, DMOTPConfig } from '../stores/dmOtpStore';
+import { shouldShowSystemMessage, generateLargeKeySystemMessage, SYSTEM_MESSAGE_KEY_THRESHOLD } from '../algorithms/otp_v1';
+import { t } from '../i18n';
+
+/**
+ * Message structure for DM
+ */
+export interface DMMessage {
+    id: string;
+    senderId: string;
+    content: string;
+    encryptedContent?: string;
+    timestamp: number;
+    isSystemMessage?: boolean;
+}
+
+/**
+ * DM conversation structure
+ */
+export interface DMConversation {
+    id: string;
+    participantIds: string[];
+    otpVersion: OTPVersion;
+    lastMessageTimestamp: number;
+}
+
+/**
+ * DM Service class
+ * Handles encryption/decryption of DM messages with OTP versioning
+ */
+class DMService {
+    /**
+     * Initialize a DM conversation with OTP settings
+     * @param conversationId Unique identifier for the conversation
+     * @param rawKey Encryption key
+     * @param otpVersion OTP version to use (default: otp_v1)
+     * @returns System message if key is large, otherwise undefined
+     */
+    initializeConversation(
+        conversationId: string,
+        rawKey: string,
+        otpVersion: OTPVersion = DEFAULT_OTP_VERSION
+    ): DMMessage | undefined {
+        // Store the configuration
+        dmOtpStore.setConfig(conversationId, {
+            otpVersion,
+            offset: 0,
+            rawKey,
+            lastUpdated: Date.now(),
+        });
+
+        // Check if we should show a system message for large keys
+        if (shouldShowSystemMessage(rawKey.length)) {
+            return {
+                id: `system-${Date.now()}`,
+                senderId: 'system',
+                content: generateLargeKeySystemMessage(rawKey.length, t().largeKeySystemMessage),
+                timestamp: Date.now(),
+                isSystemMessage: true,
+            };
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Update OTP version for a conversation
+     * @param conversationId Unique identifier for the conversation
+     * @param otpVersion New OTP version
+     */
+    updateOTPVersion(conversationId: string, otpVersion: OTPVersion): void {
+        dmOtpStore.setVersion(conversationId, otpVersion);
+    }
+
+    /**
+     * Update encryption key for a conversation
+     * @param conversationId Unique identifier for the conversation
+     * @param rawKey New encryption key
+     * @returns System message if key is large, otherwise undefined
+     */
+    updateKey(conversationId: string, rawKey: string): DMMessage | undefined {
+        dmOtpStore.setKey(conversationId, rawKey);
+
+        // Check if we should show a system message for large keys
+        if (shouldShowSystemMessage(rawKey.length)) {
+            return {
+                id: `system-${Date.now()}`,
+                senderId: 'system',
+                content: generateLargeKeySystemMessage(rawKey.length, t().largeKeySystemMessage),
+                timestamp: Date.now(),
+                isSystemMessage: true,
+            };
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Encrypt a message for sending
+     * @param conversationId Unique identifier for the conversation
+     * @param plaintext Message to encrypt
+     * @returns Encrypted message content (or plaintext if no encryption configured)
+     */
+    encryptMessage(conversationId: string, plaintext: string): string {
+        const config = dmOtpStore.getConfig(conversationId);
+        
+        if (!config || !config.rawKey) {
+            // No encryption configured - log warning and return plaintext
+            console.warn(`No encryption configured for conversation ${conversationId}. Message will be sent unencrypted.`);
+            return plaintext;
+        }
+
+        const encrypted = encryptWithVersion(
+            plaintext,
+            config.rawKey,
+            config.offset,
+            config.otpVersion
+        );
+
+        // Increment offset by message length
+        dmOtpStore.incrementOffset(conversationId, plaintext.length);
+
+        return encrypted;
+    }
+
+    /**
+     * Decrypt a received message
+     * @param conversationId Unique identifier for the conversation
+     * @param encrypted Encrypted message content
+     * @param messageLength Original message length (for offset calculation)
+     * @returns Decrypted plaintext (or original text if no encryption configured)
+     */
+    decryptMessage(conversationId: string, encrypted: string, messageLength: number): string {
+        const config = dmOtpStore.getConfig(conversationId);
+        
+        if (!config || !config.rawKey) {
+            // No encryption configured - message may be unencrypted plaintext
+            console.warn(`No encryption configured for conversation ${conversationId}. Returning message as-is.`);
+            return encrypted;
+        }
+
+        const decrypted = decryptWithVersion(
+            encrypted,
+            config.rawKey,
+            config.offset,
+            config.otpVersion
+        );
+
+        // Increment offset by message length
+        dmOtpStore.incrementOffset(conversationId, messageLength);
+
+        return decrypted;
+    }
+
+    /**
+     * Get the current OTP configuration for a conversation
+     * @param conversationId Unique identifier for the conversation
+     * @returns Current OTP configuration
+     */
+    getConfig(conversationId: string): DMOTPConfig | undefined {
+        return dmOtpStore.getConfig(conversationId);
+    }
+
+    /**
+     * Get the OTP version for a conversation
+     * @param conversationId Unique identifier for the conversation
+     * @returns Current OTP version
+     */
+    getOTPVersion(conversationId: string): OTPVersion {
+        return dmOtpStore.getVersion(conversationId);
+    }
+
+    /**
+     * Check if the conversation has encryption enabled
+     * @param conversationId Unique identifier for the conversation
+     * @returns True if encryption is configured
+     */
+    hasEncryption(conversationId: string): boolean {
+        const config = dmOtpStore.getConfig(conversationId);
+        return config !== undefined && config.rawKey.length > 0;
+    }
+
+    /**
+     * Get encryption status description
+     * @param conversationId Unique identifier for the conversation
+     * @returns Human-readable encryption status
+     */
+    getEncryptionStatus(conversationId: string): string {
+        const config = dmOtpStore.getConfig(conversationId);
+        
+        if (!config || !config.rawKey) {
+            return t().encryptionDisabled;
+        }
+
+        const algorithm = getAlgorithm(config.otpVersion);
+        return t().encryptedWith(algorithm.name);
+    }
+
+    /**
+     * Check if key is large enough to show system message
+     * @param keyLength Length of the encryption key
+     * @returns True if key is above threshold
+     */
+    isLargeKey(keyLength: number): boolean {
+        return shouldShowSystemMessage(keyLength);
+    }
+
+    /**
+     * Get the key threshold for system messages
+     * @returns Threshold value
+     */
+    getKeyThreshold(): number {
+        return SYSTEM_MESSAGE_KEY_THRESHOLD;
+    }
+
+    /**
+     * Reset encryption for a conversation
+     * @param conversationId Unique identifier for the conversation
+     */
+    resetEncryption(conversationId: string): void {
+        dmOtpStore.removeConfig(conversationId);
+    }
+
+    /**
+     * Reset offset for a conversation (for resync)
+     * @param conversationId Unique identifier for the conversation
+     */
+    resetOffset(conversationId: string): void {
+        dmOtpStore.resetOffset(conversationId);
+    }
+}
+
+// Export singleton instance (using only named export for consistency)
+export const dmService = new DMService();
diff --git a/src/services/index.ts b/src/services/index.ts
new file mode 100644
index 0000000..164b0d4
--- /dev/null
+++ b/src/services/index.ts
@@ -0,0 +1,5 @@
+// Services Index
+// Export all services
+
+export { dmService, DMMessage, DMConversation } from './dmService';
+export { dmHistoryService, DMHistoryEntry } from './DMHistoryService';
diff --git a/src/stores/dmOtpStore.ts b/src/stores/dmOtpStore.ts
new file mode 100644
index 0000000..187adf4
--- /dev/null
+++ b/src/stores/dmOtpStore.ts
@@ -0,0 +1,182 @@
+// DM OTP Store
+// Manages OTP version and key information for Direct Messages
+
+import { OTPVersion, DEFAULT_OTP_VERSION } from '../algorithms/types';
+
+/**
+ * DM OTP configuration for a conversation
+ */
+export interface DMOTPConfig {
+    /** The OTP version to use for this conversation */
+    otpVersion: OTPVersion;
+    /** Current offset in the key stream */
+    offset: number;
+    /** The raw encryption key */
+    rawKey: string;
+    /** Timestamp when the config was last updated */
+    lastUpdated: number;
+}
+
+/**
+ * Store for DM OTP configurations
+ * Maps conversation IDs to their OTP configurations
+ */
+class DMOTPStore {
+    private configs: Map<string, DMOTPConfig> = new Map();
+
+    /**
+     * Get OTP configuration for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @returns OTP configuration or undefined if not set
+     */
+    getConfig(conversationId: string): DMOTPConfig | undefined {
+        return this.configs.get(conversationId);
+    }
+
+    /**
+     * Set OTP configuration for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @param config OTP configuration
+     */
+    setConfig(conversationId: string, config: DMOTPConfig): void {
+        this.configs.set(conversationId, {
+            ...config,
+            lastUpdated: Date.now(),
+        });
+    }
+
+    /**
+     * Set just the OTP version for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @param version OTP version to use
+     */
+    setVersion(conversationId: string, version: OTPVersion): void {
+        const existing = this.configs.get(conversationId);
+        if (existing) {
+            existing.otpVersion = version;
+            existing.lastUpdated = Date.now();
+        } else {
+            this.configs.set(conversationId, {
+                otpVersion: version,
+                offset: 0,
+                rawKey: '',
+                lastUpdated: Date.now(),
+            });
+        }
+    }
+
+    /**
+     * Get the OTP version for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @returns OTP version or default if not set
+     */
+    getVersion(conversationId: string): OTPVersion {
+        const config = this.configs.get(conversationId);
+        return config?.otpVersion ?? DEFAULT_OTP_VERSION;
+    }
+
+    /**
+     * Set the encryption key for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @param rawKey The raw encryption key
+     */
+    setKey(conversationId: string, rawKey: string): void {
+        const existing = this.configs.get(conversationId);
+        if (existing) {
+            existing.rawKey = rawKey;
+            existing.offset = 0; // Reset offset when key changes
+            existing.lastUpdated = Date.now();
+        } else {
+            this.configs.set(conversationId, {
+                otpVersion: DEFAULT_OTP_VERSION,
+                offset: 0,
+                rawKey,
+                lastUpdated: Date.now(),
+            });
+        }
+    }
+
+    /**
+     * Get the current offset for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @returns Current offset in key stream
+     */
+    getOffset(conversationId: string): number {
+        const config = this.configs.get(conversationId);
+        return config?.offset ?? 0;
+    }
+
+    /**
+     * Increment the offset for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     * @param increment Amount to increment by (message length)
+     */
+    incrementOffset(conversationId: string, increment: number): void {
+        const config = this.configs.get(conversationId);
+        if (config) {
+            config.offset += increment;
+            config.lastUpdated = Date.now();
+        }
+    }
+
+    /**
+     * Reset the offset for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     */
+    resetOffset(conversationId: string): void {
+        const config = this.configs.get(conversationId);
+        if (config) {
+            config.offset = 0;
+            config.lastUpdated = Date.now();
+        }
+    }
+
+    /**
+     * Remove configuration for a conversation
+     * @param conversationId Unique identifier for the DM conversation
+     */
+    removeConfig(conversationId: string): void {
+        this.configs.delete(conversationId);
+    }
+
+    /**
+     * Clear all configurations
+     */
+    clearAll(): void {
+        this.configs.clear();
+    }
+
+    /**
+     * Get all conversation IDs with configurations
+     * @returns Array of conversation IDs
+     */
+    getAllConversationIds(): string[] {
+        return Array.from(this.configs.keys());
+    }
+
+    /**
+     * Export configurations for persistence
+     * @returns Serializable object of all configurations
+     */
+    exportConfigs(): Record<string, DMOTPConfig> {
+        const result: Record<string, DMOTPConfig> = {};
+        this.configs.forEach((config, id) => {
+            result[id] = { ...config };
+        });
+        return result;
+    }
+
+    /**
+     * Import configurations from persistence
+     * @param data Serialized configurations
+     */
+    importConfigs(data: Record<string, DMOTPConfig>): void {
+        this.configs.clear();
+        for (const [id, config] of Object.entries(data)) {
+            this.configs.set(id, { ...config });
+        }
+    }
+}
+
+// Export singleton instance (using only named export for consistency)
+export const dmOtpStore = new DMOTPStore();
diff --git a/src/stores/index.ts b/src/stores/index.ts
new file mode 100644
index 0000000..3bfce72
--- /dev/null
+++ b/src/stores/index.ts
@@ -0,0 +1,4 @@
+// Stores Index
+// Export all stores
+
+export { dmOtpStore, DMOTPConfig } from './dmOtpStore';
diff --git a/src/tsconfig.json b/src/tsconfig.json
new file mode 100644
index 0000000..7e454ab
--- /dev/null
+++ b/src/tsconfig.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./"
+  },
+  "include": [
+    "./**/*.ts",
+    "./**/*.tsx"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}