diff --git a/lib/types/media-types.js b/lib/types/media-types.js
index 14067dd33..1e27edab1 100644
--- a/lib/types/media-types.js
+++ b/lib/types/media-types.js
@@ -1,779 +1,819 @@
 // @flow
 
 import t, { type TInterface, type TUnion } from 'tcomb';
 
 import type { ClientEncryptedImageAvatar } from './avatar-types';
 import { type Platform } from './device-types.js';
 import { tShape, tString, tID } from '../utils/validation-utils.js';
 
 export type Dimensions = $ReadOnly<{
   +height: number,
   +width: number,
 }>;
 
 export const dimensionsValidator: TInterface<Dimensions> = tShape<Dimensions>({
   height: t.Number,
   width: t.Number,
 });
 
 export type MediaType = 'photo' | 'video';
 const mediaTypeValidator = t.enums.of(['photo', 'video']);
 
 export type EncryptedMediaType = 'encrypted_photo' | 'encrypted_video';
 
 export type AvatarMediaInfo =
   | ClientEncryptedImageAvatar
   | {
       +type: 'photo',
       +uri: string,
     };
 
 export type ClientDBMediaInfo = {
   +id: string,
   +uri: string,
   +type: 'photo' | 'video',
   +extras: string,
 };
 
 export type Corners = Partial<{
   +topLeft: boolean,
   +topRight: boolean,
   +bottomLeft: boolean,
   +bottomRight: boolean,
 }>;
 
 export type MediaInfo =
   | {
       ...Image,
       +index: number,
     }
   | {
       ...Video,
       +index: number,
     }
   | {
       ...EncryptedImage,
       +index: number,
     }
   | {
       ...EncryptedVideo,
       +index: number,
     };
 
 export type UploadMultimediaResult = {
   +id: string,
   +uri: string,
   +dimensions: Dimensions,
   +mediaType: MediaType,
   +loop: boolean,
 };
 export const uploadMultimediaResultValidator: TInterface<UploadMultimediaResult> =
   tShape<UploadMultimediaResult>({
     id: tID,
     uri: t.String,
     dimensions: dimensionsValidator,
     mediaType: mediaTypeValidator,
     loop: t.Boolean,
   });
 
 export type UpdateMultimediaMessageMediaPayload = {
   +messageID: string,
   +currentMediaID: string,
   +mediaUpdate: MediaShape,
 };
 
 export type UploadDeletionRequest = {
   +id: string,
 };
 
 export type UploadMediaMetadataRequest = {
   ...Dimensions,
   +filename: string,
   +blobHolder: string,
   +blobHash: string,
   +encryptionKey: string,
   +mimeType: string,
   +loop?: boolean,
   +thumbHash?: string,
 };
 
 export type FFmpegStatistics = {
   // seconds of video being processed per second
   +speed: number,
   // total milliseconds of video processed so far
   +time: number,
   // total result file size in bytes so far
   +size: number,
   +videoQuality: number,
   +videoFrameNumber: number,
   +videoFps: number,
   +bitrate: number,
 };
 
 export type TranscodeVideoMediaMissionStep = {
   +step: 'video_ffmpeg_transcode',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +returnCode: ?number,
   +newPath: ?string,
   +stats: ?FFmpegStatistics,
 };
 
 export type VideoGenerateThumbnailMediaMissionStep = {
   +step: 'video_generate_thumbnail',
   +success: boolean,
   +time: number, // ms
   +returnCode: number,
   +thumbnailURI: string,
 };
 
 export type VideoInfo = {
   +codec: ?string,
   +dimensions: ?Dimensions,
   +duration: number, // seconds
   +format: $ReadOnlyArray<string>,
 };
 
 export type VideoProbeMediaMissionStep = {
   +step: 'video_probe',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +path: string,
   +validFormat: boolean,
   +duration: ?number, // seconds
   +codec: ?string,
   +format: ?$ReadOnlyArray<string>,
   +dimensions: ?Dimensions,
 };
 
 export type ReadFileHeaderMediaMissionStep = {
   +step: 'read_file_header',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +uri: string,
   +mime: ?string,
   +mediaType: ?MediaType,
 };
 
 export type DetermineFileTypeMediaMissionStep = {
   +step: 'determine_file_type',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +inputFilename: string,
   +outputMIME: ?string,
   +outputMediaType: ?MediaType,
   +outputFilename: ?string,
 };
 
 export type FrameCountMediaMissionStep = {
   +step: 'frame_count',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number,
   +path: string,
   +mime: string,
   +hasMultipleFrames: ?boolean,
 };
 
 export type DisposeTemporaryFileMediaMissionStep = {
   +step: 'dispose_temporary_file',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +path: string,
 };
 
 export type MakeDirectoryMediaMissionStep = {
   +step: 'make_directory',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +path: string,
 };
 
 export type AndroidScanFileMediaMissionStep = {
   +step: 'android_scan_file',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +path: string,
 };
 
 export type FetchFileHashMediaMissionStep = {
   +step: 'fetch_file_hash',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +path: string,
   +hash: ?string,
 };
 
 export type CopyFileMediaMissionStep = {
   +step: 'copy_file',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +source: string,
   +destination: string,
 };
 
 export type GetOrientationMediaMissionStep = {
   +step: 'exif_fetch',
   +success: boolean,
   +exceptionMessage: ?string,
   +time: number, // ms
   +orientation: ?number,
 };
 
 export type GenerateThumbhashMediaMissionStep = {
   +step: 'generate_thumbhash',
   +success: boolean,
   +exceptionMessage: ?string,
   +thumbHash: ?string,
 };
 
 export type EncryptFileMediaMissionStep =
   | {
       +step: 'read_plaintext_file',
       +file: string,
       +time: number, // ms
       +success: boolean,
       +exceptionMessage: ?string,
     }
   | {
       +step: 'encrypt_data',
       +dataSize: number,
       +time: number, // ms
       +isPadded: boolean,
       +sha256: ?string,
       +success: boolean,
       +exceptionMessage: ?string,
     }
   | {
       +step: 'write_encrypted_file',
       +file: string,
       +time: number, // ms
       +success: boolean,
       +exceptionMessage: ?string,
     };
 
+export type DecryptFileMediaMissionStep =
+  | {
+      +step: 'fetch_file',
+      +file: string,
+      +time: number,
+      +success: boolean,
+      +exceptionMessage: ?string,
+    }
+  | {
+      +step: 'decrypt_data',
+      +dataSize: number,
+      +time: number,
+      +isPadded: boolean,
+      +success: boolean,
+      +exceptionMessage: ?string,
+    }
+  | {
+      +step: 'write_file',
+      +file: string,
+      +mimeType: string,
+      +time: number,
+      +success: boolean,
+      +exceptionMessage: ?string,
+    }
+  | {
+      +step: 'create_data_uri',
+      +mimeType: string,
+      +time: number,
+      +success: boolean,
+      +exceptionMessage: ?string,
+    };
+
 export type MediaLibrarySelection =
   | {
       +step: 'photo_library',
       +dimensions: Dimensions,
       +filename: ?string,
       +uri: string,
       +mediaNativeID: ?string,
       +selectTime: number, // ms timestamp
       +sendTime: number, // ms timestamp
       +retries: number,
     }
   | {
       +step: 'video_library',
       +dimensions: Dimensions,
       +filename: ?string,
       +uri: string,
       +mediaNativeID: ?string,
       +selectTime: number, // ms timestamp
       +sendTime: number, // ms timestamp
       +retries: number,
       +duration: number, // seconds
     };
 
 export const mediaLibrarySelectionValidator: TUnion<MediaLibrarySelection> =
   t.union([
     tShape({
       step: tString('photo_library'),
       dimensions: dimensionsValidator,
       filename: t.maybe(t.String),
       uri: t.String,
       mediaNativeID: t.maybe(t.String),
       selectTime: t.Number,
       sendTime: t.Number,
       retries: t.Number,
     }),
     tShape({
       step: tString('video_library'),
       dimensions: dimensionsValidator,
       filename: t.maybe(t.String),
       uri: t.String,
       mediaNativeID: t.maybe(t.String),
       selectTime: t.Number,
       sendTime: t.Number,
       retries: t.Number,
       duration: t.Number,
     }),
   ]);
 
 export type PhotoCapture = {
   +step: 'photo_capture',
   +time: number, // ms
   +dimensions: Dimensions,
   +filename: string,
   +uri: string,
   +captureTime: number, // ms timestamp
   +selectTime: number, // ms timestamp
   +sendTime: number, // ms timestamp
   +retries: number,
 };
 
 export const photoCaptureValidator: TInterface<PhotoCapture> =
   tShape<PhotoCapture>({
     step: tString('photo_capture'),
     time: t.Number,
     dimensions: dimensionsValidator,
     filename: t.String,
     uri: t.String,
     captureTime: t.Number,
     selectTime: t.Number,
     sendTime: t.Number,
     retries: t.Number,
   });
 
 export type PhotoPaste = {
   +step: 'photo_paste',
   +dimensions: Dimensions,
   +filename: string,
   +uri: string,
   +selectTime: number, // ms timestamp
   +sendTime: number, // ms timestamp
   +retries: number,
 };
 
 export const photoPasteValidator: TInterface<PhotoPaste> = tShape<PhotoPaste>({
   step: tString('photo_paste'),
   dimensions: dimensionsValidator,
   filename: t.String,
   uri: t.String,
   selectTime: t.Number,
   sendTime: t.Number,
   retries: t.Number,
 });
 
 export type NativeMediaSelection =
   | MediaLibrarySelection
   | PhotoCapture
   | PhotoPaste;
 
 export const nativeMediaSelectionValidator: TUnion<NativeMediaSelection> =
   t.union([
     mediaLibrarySelectionValidator,
     photoCaptureValidator,
     photoPasteValidator,
   ]);
 
 export type MediaMissionStep =
   | NativeMediaSelection
   | {
       +step: 'web_selection',
       +filename: string,
       +size: number, // in bytes
       +mime: string,
       +selectTime: number, // ms timestamp
     }
   | {
       +step: 'asset_info_fetch',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +localURI: ?string,
       +orientation: ?number,
     }
   | {
       +step: 'stat_file',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +uri: string,
       +fileSize: ?number,
     }
   | ReadFileHeaderMediaMissionStep
   | DetermineFileTypeMediaMissionStep
   | FrameCountMediaMissionStep
   | {
       +step: 'photo_manipulation',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +manipulation: Object,
       +newMIME: ?string,
       +newDimensions: ?Dimensions,
       +newURI: ?string,
     }
   | VideoProbeMediaMissionStep
   | TranscodeVideoMediaMissionStep
   | VideoGenerateThumbnailMediaMissionStep
   | DisposeTemporaryFileMediaMissionStep
   | {
       +step: 'save_media',
       +uri: string,
       +time: number, // ms timestamp
     }
   | {
       +step: 'permissions_check',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +platform: Platform,
       +permissions: $ReadOnlyArray<string>,
     }
   | MakeDirectoryMediaMissionStep
   | AndroidScanFileMediaMissionStep
   | {
       +step: 'ios_save_to_library',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +uri: string,
     }
   | {
       +step: 'fetch_blob',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +inputURI: string,
       +uri: string,
       +size: ?number,
       +mime: ?string,
     }
   | {
       +step: 'data_uri_from_blob',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +first255Chars: ?string,
     }
   | {
       +step: 'array_buffer_from_blob',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
     }
   | {
       +step: 'mime_check',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +mime: ?string,
     }
   | {
       +step: 'write_file',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +path: string,
       +length: number,
     }
   | FetchFileHashMediaMissionStep
   | CopyFileMediaMissionStep
   | EncryptFileMediaMissionStep
+  | DecryptFileMediaMissionStep
   | GetOrientationMediaMissionStep
   | GenerateThumbhashMediaMissionStep
   | {
       +step: 'preload_resource',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +uri: string,
     }
   | {
       +step: 'preload_image',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +uri: string,
       +dimensions: ?Dimensions,
     }
   | {
       +step: 'reorient_image',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +uri: ?string,
     }
   | {
       +step: 'upload',
       +success: boolean,
       +exceptionMessage: ?string,
       +time: number, // ms
       +inputFilename: string,
       +outputMediaType: ?MediaType,
       +outputURI: ?string,
       +outputDimensions: ?Dimensions,
       +outputLoop: ?boolean,
       +hasWiFi?: boolean,
     }
   | {
       +step: 'wait_for_capture_uri_unload',
       +success: boolean,
       +time: number, // ms
       +uri: string,
     };
 
 export type MediaMissionFailure =
   | {
       +success: false,
       +reason: 'no_file_path',
     }
   | {
       +success: false,
       +reason: 'file_stat_failed',
       +uri: string,
     }
   | {
       +success: false,
       +reason: 'photo_manipulation_failed',
       +size: number, // in bytes
     }
   | {
       +success: false,
       +reason: 'media_type_fetch_failed',
       +detectedMIME: ?string,
     }
   | {
       +success: false,
       +reason: 'mime_type_mismatch',
       +reportedMediaType: MediaType,
       +reportedMIME: string,
       +detectedMIME: string,
     }
   | {
       +success: false,
       +reason: 'http_upload_failed',
       +exceptionMessage: ?string,
     }
   | {
       +success: false,
       +reason: 'video_too_long',
       +duration: number, // in seconds
     }
   | {
       +success: false,
       +reason: 'video_probe_failed',
     }
   | {
       +success: false,
       +reason: 'video_transcode_failed',
     }
   | {
       +success: false,
       +reason: 'video_generate_thumbnail_failed',
     }
   | {
       +success: false,
       +reason: 'processing_exception',
       +time: number, // ms
       +exceptionMessage: ?string,
     }
   | {
       +success: false,
       +reason: 'encryption_exception',
       +time: number, // ms
       +exceptionMessage: ?string,
     }
   | {
       +success: false,
       +reason: 'save_unsupported',
     }
   | {
       +success: false,
       +reason: 'missing_permission',
     }
   | {
       +success: false,
       +reason: 'make_directory_failed',
     }
   | {
       +success: false,
       +reason: 'resolve_failed',
       +uri: string,
     }
   | {
       +success: false,
       +reason: 'save_to_library_failed',
       +uri: string,
     }
   | {
       +success: false,
       +reason: 'fetch_failed',
     }
   | {
       +success: false,
       +reason: 'data_uri_failed',
     }
   | {
       +success: false,
       +reason: 'array_buffer_failed',
     }
   | {
       +success: false,
       +reason: 'mime_check_failed',
       +mime: ?string,
     }
   | {
       +success: false,
       +reason: 'write_file_failed',
     }
   | {
       +success: false,
       +reason: 'fetch_file_hash_failed',
     }
   | {
       +success: false,
       +reason: 'copy_file_failed',
     }
   | {
       +success: false,
       +reason: 'exif_fetch_failed',
     }
   | {
       +success: false,
       +reason: 'reorient_image_failed',
     }
   | {
       +success: false,
       +reason: 'web_sibling_validation_failed',
     }
   | {
       +success: false,
       +reason: 'encryption_failed',
     }
   | { +success: false, +reason: 'digest_failed' }
   | { +success: false, +reason: 'thumbhash_failed' }
-  | { +success: false, +reason: 'preload_image_failed' };
+  | { +success: false, +reason: 'preload_image_failed' }
+  | DecryptionFailure;
+
+export type DecryptionFailure = {
+  +success: false,
+  +reason: 'fetch_file_failed' | 'decrypt_data_failed' | 'write_file_failed',
+  +exceptionMessage: ?string,
+};
 
 export type MediaMissionResult = MediaMissionFailure | { +success: true };
 
 export type MediaMission = {
   +steps: $ReadOnlyArray<MediaMissionStep>,
   +result: MediaMissionResult,
   +userTime: number,
   +totalTime: number,
 };
 
 export type Image = {
   +id: string,
   +uri: string,
   +type: 'photo',
   +dimensions: Dimensions,
   +thumbHash: ?string,
   // stored on native only during creation in case retry needed after state lost
   +localMediaSelection?: NativeMediaSelection,
 };
 
 export const imageValidator: TInterface<Image> = tShape<Image>({
   id: tID,
   uri: t.String,
   type: tString('photo'),
   dimensions: dimensionsValidator,
   thumbHash: t.maybe(t.String),
   localMediaSelection: t.maybe(nativeMediaSelectionValidator),
 });
 
 type EncryptedImageCommons = {
   +id: string,
   +encryptionKey: string,
   +type: 'encrypted_photo',
   +dimensions: Dimensions,
   +thumbHash: ?string,
 };
 // old message formats (native codeVersion < FUTURE_CODE_VERSION) used holder
 // new format uses blobURI. Effectively, they both mean blob URI
 export type EncryptedImage =
   | { ...EncryptedImageCommons, +holder: string }
   | { ...EncryptedImageCommons, +blobURI: string };
 
 const encryptedImageCommonsValidator = {
   id: tID,
   encryptionKey: t.String,
   type: tString('encrypted_photo'),
   dimensions: dimensionsValidator,
   thumbHash: t.maybe(t.String),
 };
 
 const encryptedImageValidator = t.union<EncryptedImage>([
   tShape({ ...encryptedImageCommonsValidator, holder: t.String }),
   tShape({ ...encryptedImageCommonsValidator, blobURI: t.String }),
 ]);
 
 export type Video = {
   +id: string,
   +uri: string,
   +type: 'video',
   +dimensions: Dimensions,
   +loop?: boolean,
   +thumbnailID: string,
   +thumbnailURI: string,
   +thumbnailThumbHash: ?string,
   // stored on native only during creation in case retry needed after state lost
   +localMediaSelection?: NativeMediaSelection,
 };
 
 export const videoValidator: TInterface<Video> = tShape<Video>({
   id: tID,
   uri: t.String,
   type: tString('video'),
   dimensions: dimensionsValidator,
   loop: t.maybe(t.Boolean),
   thumbnailID: tID,
   thumbnailURI: t.String,
   thumbnailThumbHash: t.maybe(t.String),
   localMediaSelection: t.maybe(nativeMediaSelectionValidator),
 });
 
 type EncryptedVideoCommons = {
   +id: string,
   +encryptionKey: string,
   +type: 'encrypted_video',
   +dimensions: Dimensions,
   +loop?: boolean,
   +thumbnailID: string,
   +thumbnailEncryptionKey: string,
   +thumbnailThumbHash: ?string,
 };
 // old message formats (native codeVersion < FUTURE_CODE_VERSION) used holder
 // new format uses blobURI. Effectively, they both mean blob URI
 export type EncryptedVideo =
   | { ...EncryptedVideoCommons, +holder: string, +thumbnailHolder: string }
   | { ...EncryptedVideoCommons, +blobURI: string, +thumbnailBlobURI: string };
 
 const encryptedVideoCommonsValidator = {
   id: tID,
   encryptionKey: t.String,
   type: tString('encrypted_video'),
   dimensions: dimensionsValidator,
   loop: t.maybe(t.Boolean),
   thumbnailID: tID,
   thumbnailEncryptionKey: t.String,
   thumbnailThumbHash: t.maybe(t.String),
 };
 const encryptedVideoValidator = t.union<EncryptedVideo>([
   tShape({
     ...encryptedVideoCommonsValidator,
     holder: t.String,
     thumbnailHolder: t.String,
   }),
   tShape({
     ...encryptedVideoCommonsValidator,
     blobURI: t.String,
     thumbnailBlobURI: t.String,
   }),
 ]);
 
 export type Media = Image | Video | EncryptedImage | EncryptedVideo;
 export type MediaShape =
   | Partial<Image>
   | Partial<Video>
   | Partial<EncryptedImage>
   | Partial<EncryptedVideo>;
 
 export const mediaValidator: TUnion<Media> = t.union([
   imageValidator,
   videoValidator,
   encryptedImageValidator,
   encryptedVideoValidator,
 ]);
diff --git a/native/media/encryption-utils.js b/native/media/encryption-utils.js
index 01d2f4d8f..e28001608 100644
--- a/native/media/encryption-utils.js
+++ b/native/media/encryption-utils.js
@@ -1,451 +1,410 @@
 // @flow
 
 import invariant from 'invariant';
 
 import { uintArrayToHexString, hexToUintArray } from 'lib/media/data-utils.js';
 import {
   replaceExtension,
   fileInfoFromData,
   filenameFromPathOrURI,
   readableFilename,
   pathFromURI,
 } from 'lib/media/file-utils.js';
 import type {
   MediaMissionFailure,
   MediaMissionStep,
+  DecryptFileMediaMissionStep,
   EncryptFileMediaMissionStep,
 } from 'lib/types/media-types.js';
 import { getMessageForException } from 'lib/utils/errors.js';
 import { pad, unpad, calculatePaddedLength } from 'lib/utils/pkcs7-padding.js';
 
 import { temporaryDirectoryPath } from './file-utils.js';
 import { getFetchableURI } from './identifier-utils.js';
 import type { MediaResult } from './media-utils.js';
 import { commUtilsModule } from '../native-modules.js';
 import * as AES from '../utils/aes-crypto-module.js';
 import { arrayBufferFromBlob } from '../utils/blob-utils-module.js';
 
 const PADDING_THRESHOLD = 5000000; // we don't pad files larger than this
 
 type EncryptedFileResult = {
   +success: true,
   +uri: string,
   +sha256Hash: string,
   +encryptionKey: string,
 };
 
 /**
  * Encrypts a single file and returns the encrypted file URI
  * and the encryption key. The encryption key is returned as a hex string.
  * The encrypted file is written to the same directory as the original file,
  * with the same name, but with the extension ".dat".
  *
  * @param uri uri to the file to encrypt
  * @returns encryption result along with mission steps
  */
 async function encryptFile(uri: string): Promise<{
   steps: $ReadOnlyArray<EncryptFileMediaMissionStep>,
   result: MediaMissionFailure | EncryptedFileResult,
 }> {
   let success = true,
     exceptionMessage;
   const steps: EncryptFileMediaMissionStep[] = [];
 
   // prepare destination path for temporary encrypted file
   const originalFilename = filenameFromPathOrURI(uri);
   invariant(originalFilename, 'encryptFile: Invalid URI - filename is null');
   const targetFilename = replaceExtension(originalFilename, 'dat');
   const destinationPath = `${temporaryDirectoryPath}${targetFilename}`;
   const destinationURI = `file://${destinationPath}`;
 
   // Step 1. Read the file
   const startOpenFile = Date.now();
   let data;
   try {
     const path = pathFromURI(uri);
     // for local paths (file:// URI) we can use native module which is faster
     if (path) {
       const buffer = await commUtilsModule.readBufferFromFile(path);
       data = new Uint8Array(buffer);
     } else {
       const response = await fetch(getFetchableURI(uri));
       const blob = await response.blob();
       const buffer = arrayBufferFromBlob(blob);
       data = new Uint8Array(buffer);
     }
   } catch (e) {
     success = false;
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'read_plaintext_file',
     file: uri,
     time: Date.now() - startOpenFile,
     success,
     exceptionMessage,
   });
   if (!success || !data) {
     return {
       steps,
       result: { success: false, reason: 'fetch_failed' },
     };
   }
 
   // Step 2. Encrypt the file
   const startEncrypt = Date.now();
   const paddedLength = calculatePaddedLength(data.byteLength);
   const shouldPad = paddedLength <= PADDING_THRESHOLD;
   let key, encryptedData, sha256Hash;
   try {
     const plaintextData = shouldPad ? pad(data) : data;
     key = AES.generateKey();
     encryptedData = AES.encrypt(key, plaintextData);
     sha256Hash = commUtilsModule.sha256(encryptedData.buffer);
   } catch (e) {
     success = false;
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'encrypt_data',
     dataSize: encryptedData?.byteLength ?? -1,
     isPadded: shouldPad,
     time: Date.now() - startEncrypt,
     sha256: sha256Hash,
     success,
     exceptionMessage,
   });
   if (encryptedData && !sha256Hash) {
     return { steps, result: { success: false, reason: 'digest_failed' } };
   }
   if (!success || !encryptedData || !key || !sha256Hash) {
     return {
       steps,
       result: { success: false, reason: 'encryption_failed' },
     };
   }
 
   // Step 3. Write the encrypted file
   const startWriteFile = Date.now();
   try {
     await commUtilsModule.writeBufferToFile(
       destinationPath,
       encryptedData.buffer,
     );
   } catch (e) {
     success = false;
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'write_encrypted_file',
     file: destinationPath,
     time: Date.now() - startWriteFile,
     success,
     exceptionMessage,
   });
   if (!success) {
     return {
       steps,
       result: { success: false, reason: 'write_file_failed' },
     };
   }
 
   return {
     steps,
     result: {
       success: true,
       uri: destinationURI,
       encryptionKey: uintArrayToHexString(key),
       sha256Hash,
     },
   };
 }
 
 /**
  * Encrypts a single photo or video. Replaces the uploadURI with the encrypted
  * file URI. Attaches `encryptionKey` to the result. Changes the mediaType to
  * `encrypted_photo` or `encrypted_video`.
  *
  * @param preprocessedMedia - Result of `processMedia()` call
  * @returns a `preprocessedMedia` param, but with encryption applied
  */
 async function encryptMedia(preprocessedMedia: MediaResult): Promise<{
   result: MediaResult | MediaMissionFailure,
   steps: $ReadOnlyArray<MediaMissionStep>,
 }> {
   invariant(preprocessedMedia.success, 'encryptMedia called on failure result');
   invariant(
     preprocessedMedia.mediaType === 'photo' ||
       preprocessedMedia.mediaType === 'video',
     'encryptMedia should only be called on unencrypted photos and videos',
   );
   const { uploadURI } = preprocessedMedia;
   const steps: Array<MediaMissionStep> = [];
 
   // Encrypt the media file
   const { steps: encryptionSteps, result: encryptionResult } =
     await encryptFile(uploadURI);
   steps.push(...encryptionSteps);
 
   if (!encryptionResult.success) {
     return { steps, result: encryptionResult };
   }
 
   if (preprocessedMedia.mediaType === 'photo') {
     const thumbHashResult = preprocessedMedia.thumbHash
       ? encryptBase64(
           preprocessedMedia.thumbHash,
           hexToUintArray(encryptionResult.encryptionKey),
         )
       : null;
     return {
       steps,
       result: {
         ...preprocessedMedia,
         mediaType: 'encrypted_photo',
         uploadURI: encryptionResult.uri,
         blobHash: encryptionResult.sha256Hash,
         thumbHash: thumbHashResult?.base64,
         encryptionKey: encryptionResult.encryptionKey,
         shouldDisposePath: pathFromURI(encryptionResult.uri),
       },
     };
   }
 
   // For videos, we also need to encrypt the thumbnail
   const { steps: thumbnailEncryptionSteps, result: thumbnailEncryptionResult } =
     await encryptFile(preprocessedMedia.uploadThumbnailURI);
   steps.push(...thumbnailEncryptionSteps);
 
   if (!thumbnailEncryptionResult.success) {
     return { steps, result: thumbnailEncryptionResult };
   }
 
   const thumbHashResult = preprocessedMedia.thumbHash
     ? encryptBase64(
         preprocessedMedia.thumbHash,
         hexToUintArray(thumbnailEncryptionResult.encryptionKey),
       )
     : null;
 
   return {
     steps,
     result: {
       ...preprocessedMedia,
       mediaType: 'encrypted_video',
       uploadURI: encryptionResult.uri,
       blobHash: encryptionResult.sha256Hash,
       thumbHash: thumbHashResult?.base64,
       encryptionKey: encryptionResult.encryptionKey,
       uploadThumbnailURI: thumbnailEncryptionResult.uri,
       thumbnailBlobHash: thumbnailEncryptionResult.sha256Hash,
       thumbnailEncryptionKey: thumbnailEncryptionResult.encryptionKey,
       shouldDisposePath: pathFromURI(encryptionResult.uri),
     },
   };
 }
 
-type DecryptFileStep =
-  | {
-      +step: 'fetch_file',
-      +file: string,
-      +time: number,
-      +success: boolean,
-      +exceptionMessage: ?string,
-    }
-  | {
-      +step: 'decrypt_data',
-      +dataSize: number,
-      +time: number,
-      +isPadded: boolean,
-      +success: boolean,
-      +exceptionMessage: ?string,
-    }
-  | {
-      +step: 'write_file',
-      +file: string,
-      +mimeType: string,
-      +time: number,
-      +success: boolean,
-      +exceptionMessage: ?string,
-    }
-  | {
-      +step: 'create_data_uri',
-      +mimeType: string,
-      +time: number,
-      +success: boolean,
-      +exceptionMessage: ?string,
-    };
-type DecryptionFailure =
-  | MediaMissionFailure
-  | {
-      +success: false,
-      +reason:
-        | 'fetch_file_failed'
-        | 'decrypt_data_failed'
-        | 'write_file_failed',
-      +exceptionMessage: ?string,
-    };
-
 async function decryptMedia(
   blobURI: string,
   encryptionKey: string,
   options: {
     +destination: 'file' | 'data_uri',
     +destinationDirectory?: string,
   },
 ): Promise<{
-  steps: $ReadOnlyArray<DecryptFileStep>,
-  result: DecryptionFailure | { success: true, uri: string },
+  steps: $ReadOnlyArray<DecryptFileMediaMissionStep>,
+  result: MediaMissionFailure | { success: true, uri: string },
 }> {
   let success = true,
     exceptionMessage;
-  const steps: DecryptFileStep[] = [];
+  const steps: DecryptFileMediaMissionStep[] = [];
 
   // Step 1. Fetch the file and convert it to a Uint8Array
   const fetchStartTime = Date.now();
   let data;
   try {
     const response = await fetch(getFetchableURI(blobURI));
     if (!response.ok) {
       throw new Error(`HTTP error ${response.status}: ${response.statusText}`);
     }
     const blob = await response.blob();
     const buffer = arrayBufferFromBlob(blob);
     data = new Uint8Array(buffer);
   } catch (e) {
     success = false;
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'fetch_file',
     file: blobURI,
     time: Date.now() - fetchStartTime,
     success,
     exceptionMessage,
   });
   if (!success || !data) {
     return {
       steps,
       result: { success: false, reason: 'fetch_file_failed', exceptionMessage },
     };
   }
 
   // Step 2. Decrypt the data
   const decryptionStartTime = Date.now();
   let plaintextData, decryptedData, isPadded;
   try {
     const key = hexToUintArray(encryptionKey);
     plaintextData = AES.decrypt(key, data);
     isPadded = plaintextData.byteLength <= PADDING_THRESHOLD;
     decryptedData = isPadded ? unpad(plaintextData) : plaintextData;
   } catch (e) {
     success = false;
     exceptionMessage = getMessageForException(e);
   }
   steps.push({
     step: 'decrypt_data',
     dataSize: decryptedData?.byteLength ?? -1,
     isPadded: !!isPadded,
     time: Date.now() - decryptionStartTime,
     success,
     exceptionMessage,
   });
 
   if (!success || !decryptedData) {
     return {
       steps,
       result: {
         success: false,
         reason: 'decrypt_data_failed',
         exceptionMessage,
       },
     };
   }
 
   // Step 3. Write the file to disk or create a data URI
   let uri;
   const writeStartTime = Date.now();
   // we need extension for react-native-video to work
   const { mime } = fileInfoFromData(decryptedData);
   if (!mime) {
     return {
       steps,
       result: {
         success: false,
         reason: 'mime_check_failed',
         mime,
       },
     };
   }
   if (options.destination === 'file') {
     // blobURI is a URL, we use the last part of the path as the filename
     const uriSuffix = blobURI.substring(blobURI.lastIndexOf('/') + 1);
     const filename = readableFilename(uriSuffix, mime) || uriSuffix;
     const directory = options.destinationDirectory ?? temporaryDirectoryPath;
     const targetPath = `${directory}${Date.now()}-${filename}`;
     try {
       await commUtilsModule.writeBufferToFile(targetPath, decryptedData.buffer);
     } catch (e) {
       success = false;
       exceptionMessage = getMessageForException(e);
     }
     uri = `file://${targetPath}`;
     steps.push({
       step: 'write_file',
       file: uri,
       mimeType: mime,
       time: Date.now() - writeStartTime,
       success,
       exceptionMessage,
     });
     if (!success) {
       return {
         steps,
         result: {
           success: false,
           reason: 'write_file_failed',
           exceptionMessage,
         },
       };
     }
   } else {
     const base64 = commUtilsModule.base64EncodeBuffer(decryptedData.buffer);
     uri = `data:${mime};base64,${base64}`;
     steps.push({
       step: 'create_data_uri',
       mimeType: mime,
       time: Date.now() - writeStartTime,
       success,
       exceptionMessage,
     });
   }
 
   return {
     steps,
     result: { success: true, uri },
   };
 }
 
 function encryptBase64(
   base64: string,
   keyBytes?: Uint8Array,
 ): { +base64: string, +keyHex: string } {
   const rawData = commUtilsModule.base64DecodeBuffer(base64);
   const aesKey = keyBytes ?? AES.generateKey();
   const encrypted = AES.encrypt(aesKey, new Uint8Array(rawData));
   return {
     base64: commUtilsModule.base64EncodeBuffer(encrypted.buffer),
     keyHex: uintArrayToHexString(aesKey),
   };
 }
 
 function decryptBase64(encrypted: string, keyHex: string): string {
   const encryptedData = commUtilsModule.base64DecodeBuffer(encrypted);
   const decryptedData = AES.decrypt(
     hexToUintArray(keyHex),
     new Uint8Array(encryptedData),
   );
   return commUtilsModule.base64EncodeBuffer(decryptedData.buffer);
 }
 
 export { encryptMedia, decryptMedia, encryptBase64, decryptBase64 };