How to fix storage/invalid-checksum in Firebase

// Web SDK example with retry logic
import { ref, uploadBytes } from 'firebase/storage';

async function uploadWithRetry(storage, filePath, file, maxRetries = 3) {
  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const storageRef = ref(storage, filePath);
      const result = await uploadBytes(storageRef, file);
      console.log('Upload successful on attempt', attempt);
      return result;
    } catch (error) {
      lastError = error;

      if (error.code === 'storage/invalid-checksum') {
        console.log(`Checksum error on attempt ${attempt}/${maxRetries}`);

        if (attempt < maxRetries) {
          // Exponential backoff: 1s, 2s, 4s
          const delay = Math.pow(2, attempt - 1) * 1000;
          console.log(`Retrying in ${delay}ms...`);
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      } else {
        // Non-checksum error, don't retry
        throw error;
      }
    }
  }

  throw lastError;
}

// Usage
try {
  await uploadWithRetry(storage, 'uploads/myfile.pdf', fileBlob);
} catch (error) {
  console.error('Upload failed after all retries:', error);
}

// Web SDK - Resumable upload with pause/resume capability
import { ref, uploadBytesResumable } from 'firebase/storage';

function uploadLargeFile(storage, filePath, file) {
  const storageRef = ref(storage, filePath);
  const uploadTask = uploadBytesResumable(storageRef, file);

  return new Promise((resolve, reject) => {
    uploadTask.on('state_changed',
      // Progress observer
      (snapshot) => {
        const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
        console.log('Upload is ' + progress + '% done');

        switch (snapshot.state) {
          case 'paused':
            console.log('Upload is paused');
            break;
          case 'running':
            console.log('Upload is running');
            break;
        }
      },
      // Error observer
      (error) => {
        if (error.code === 'storage/invalid-checksum') {
          console.error('Checksum mismatch - retrying upload');
        }
        reject(error);
      },
      // Success observer
      () => {
        console.log('Upload completed successfully');
        resolve(uploadTask.snapshot);
      }
    );
  });
}

// Usage
try {
  await uploadLargeFile(storage, 'uploads/large-file.mp4', videoFile);
} catch (error) {
  console.error('Upload failed:', error);
}

// Create immutable copy of file before upload
async function uploadImmutableFile(storage, filePath, file) {
  // For File objects (from input), create a Blob copy
  const immutableBlob = file.slice(0, file.size, file.type);

  // Store original file size for verification
  const originalSize = file.size;

  const storageRef = ref(storage, filePath);

  try {
    const result = await uploadBytes(storageRef, immutableBlob);
    return result;
  } catch (error) {
    if (error.code === 'storage/invalid-checksum') {
      console.error('Checksum error - file may have been modified');
      console.error('Original size:', originalSize);
      console.error('Current size:', file.size);
    }
    throw error;
  }
}

// For Node.js environment - read file once into buffer
const fs = require('fs');
const { getStorage, ref, uploadBytes } = require('firebase-admin/storage');

async function uploadFileFromDisk(filePath, storagePath) {
  // Read entire file into memory at once (immutable)
  const fileBuffer = fs.readFileSync(filePath);

  const storage = getStorage();
  const storageRef = ref(storage, storagePath);

  // Upload from buffer (no concurrent modifications)
  await uploadBytes(storageRef, fileBuffer);
}

# For web projects
npm update firebase

# Check current version
npm list firebase

# Or update to specific latest version
npm install firebase@latest

# For React Native
npm update @react-native-firebase/storage

# For Flutter
flutter pub upgrade firebase_storage

// Check Firebase SDK version
import { SDK_VERSION } from 'firebase/app';
console.log('Firebase SDK version:', SDK_VERSION);

// For Admin SDK
const admin = require('firebase-admin');
console.log('Admin SDK version:', admin.SDK_VERSION);

// Monitor network status during upload
function monitorNetworkDuringUpload(uploadTask) {
  // Check if online
  if (!navigator.onLine) {
    console.warn('Browser is offline');
    uploadTask.pause();
    return;
  }

  // Listen for network changes
  window.addEventListener('online', () => {
    console.log('Connection restored, resuming upload');
    uploadTask.resume();
  });

  window.addEventListener('offline', () => {
    console.log('Connection lost, pausing upload');
    uploadTask.pause();
  });

  // Monitor connection quality
  if ('connection' in navigator) {
    const connection = navigator.connection;
    console.log('Connection type:', connection.effectiveType);

    connection.addEventListener('change', () => {
      console.log('Connection changed to:', connection.effectiveType);

      // Pause on slow connections
      if (connection.effectiveType === 'slow-2g' || connection.effectiveType === '2g') {
        console.warn('Slow connection detected, pausing upload');
        uploadTask.pause();
      }
    });
  }
}

// Usage with resumable upload
const uploadTask = uploadBytesResumable(storageRef, file);
monitorNetworkDuringUpload(uploadTask);