📘 SimpleSDK API Reference

class WalletBackupService {
    constructor(apiKey, apiUrl) {
        this.apiKey = apiKey;
        this.apiUrl = apiUrl;
        this.sdk = null;
    }
    
    // Initialize SDK for user
    initForUser(userId) {
        this.sdk = new SeadSimpleWithAPI({
            apiUrl: this.apiUrl,
            apiKey: this.apiKey,
            userId: userId
        });
    }
    
    // Backup with full error handling
    async createBackup(seedPhrase, options = {}) {
        if (!this.sdk) {
            throw new Error('SDK not initialized');
        }
        
        const defaultOptions = {
            n: 3,
            m: 2,
            allowNonBIP39: false,
            onPaymentRequired: this.handlePayment.bind(this)
        };
        
        const finalOptions = {
            ...defaultOptions,
            ...options,
            seedPhrase
        };
        
        try {
            const result = await this.sdk.backup(finalOptions);
            
            if (result.success) {
                // Store backup metadata
                await this.storeBackupMetadata({
                    backupId: result.backupId,
                    timestamp: Date.now(),
                    sharesCount: result.shares.length,
                    encrypted: result.encryptionUsed
                });
                
                return result;
            }
            
            throw new Error(result.error || 'Backup failed');
            
        } catch (error) {
            // Log error for monitoring
            console.error('Backup error:', error);
            
            // Translate to user-friendly message
            const userMessage = this.translateError(error.message);
            throw new Error(userMessage);
        }
    }
    
    // Restore with validation
    async restoreWallet(shares, password) {
        if (!this.sdk) {
            // For restore, we can use temporary user ID
            this.initForUser('restore_' + Date.now());
        }
        
        // Validate shares
        if (!shares || shares.length < 2) {
            throw new Error('At least 2 shares required');
        }
        
        try {
            const result = await this.sdk.restore({
                shareTexts: shares,
                password: password,
                allowNonBIP39: true  // Allow any previously backed up phrase
            });
            
            if (result.success) {
                return result.seedPhrase;
            }
            
            throw new Error(result.error || 'Restore failed');
            
        } catch (error) {
            console.error('Restore error:', error);
            
            if (error.message.includes('password')) {
                throw new Error('Incorrect password');
            }
            
            throw new Error('Invalid shares or corrupted data');
        }
    }
    
    // Payment handler
    async handlePayment(amount, currency) {
        // Implement your payment flow
        const tx = await this.processPayment(amount, currency);
        return {
            transactionId: tx.hash,
            proof: tx.signature
        };
    }
    
    // Error translation
    translateError(error) {
        const errorMap = {
            'Quota exhausted': 'You have used all free backups. Payment required.',
            'Invalid API key': 'Service configuration error. Please contact support.',
            'Network error': 'Cannot connect to backup service. Please try again.',
            'Invalid seed': 'The provided seed phrase is invalid.',
            'Rate limited': 'Too many attempts. Please wait and try again.'
        };
        
        for (const [key, message] of Object.entries(errorMap)) {
            if (error.includes(key)) {
                return message;
            }
        }
        
        return 'An unexpected error occurred. Please try again.';
    }
}