diff --git a/.pvsconfig b/.pvsconfig
index a9ab9c9f66..49c63ad739 100644
--- a/.pvsconfig
+++ b/.pvsconfig
@@ -44,3 +44,6 @@
 
 # Functions that always return the same error code
 //-V:picopass_device_decrypt:1048
+
+# Examples
+//V_EXCLUDE_PATH applications/examples/
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27bf40e1c7..1d75cab2f0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,27 +1,39 @@
 ### New changes
 * If you have copied apps into `apps` folder - remove `apps` folder on your microSD before installing this release to avoid issues!
-* SubGHz: Fixed timings for static CAME 12 bit and other types (fixed issue #280)
-* SubGHz: Fix #370 and fix other protocol counter issues
-* SubGHz: **Custom buttons for Nice Flor S / Somfy Telis (+Programming mode)** - now you can use arrow buttons to send signal with different button code
-* SubGHz: Somfy Telis -> Add manually (create new remote, now with programming button (Prog / 0x8) you can write it into receiver)
-* SubGHz: BFT Mitto -> Add manually (create new remote, now with programming button (0xF) you can write it into receiver)
-* SubGHz: Nice One -> Add manually (programming is possible using regular button)
-* SubGHz: More precise settings for debug counter increase value
-* Plugins -> MouseJacker: Features, Fixes and improvements (by @MatthisC | PR #366)
-* Plugins -> HC-SR04: Improve accuracy by measuring microseconds (by @clashlab | PR #367)
-* OFW PR: 2441 - Infrared: Fix hangups on repeated button press (by gsurkov)
-* OFW PR: 2440 - Fix navigation on unsupported card types (by Astrrra)
-* OFW: BadUSB UI fixes
-* OFW: Plugins: move to designated categories -> **We moved some plugins to new categories too**
-* OFW: Drivers: remove excessive check in bq25896 and make PVS happy
-* OFW: FuriHal, Power, UnitTests: fix, rename battery charging voltage limit API -> **Breaking API change, api was changed from 14.x to 15.x** 
+* SubGHz: Default custom buttons layout for non standard remotes (for example your remote has broken buttons and transmit only 0xC, now you can use other buttons)
+* SubGHz: Fix issues with external module 5v power (now all works automatically, enabling +5v manually not required) (**Only for modules that work with 5v->3.3v converter!!!!!**)
+* SubGHz: Option to disable automatic 5v power for external modules - (5v is enabled by default, if you are using module without converter you can set this option to OFF)
+* SubGHz: Fix and update subghz protocols to use new error system
+* SubGHz: Fix default frequency being overwritten bug (Add manually fixes)
+* SubGHz: Fix 464Mhz and (390MHz for external module only) was showing up in Frequency analyzer all the time due to noise
+* iButton: Fix ibutton app - add manually - duplicate names
+* Plugins: NFC Magic fix - reinit nfc at app start
+* Plugins: Update **Unitemp - Temperature sensors reader** (DHT11/22, DS18B20, BMP280, HTU21x and more) [(by quen0n)](https://github.com/quen0n/unitemp-flipperzero)
+* Plugins: Update **SWD Probe** [(by g3gg0)](https://github.com/g3gg0/flipper-swd_probe)
+* Plugins: Massive plugins refactoring - not full refactoring, only small issues is fixed and moved all plugins to furi mutex instead of valuemutex
+* Plugins: Many small issues was found and fixed due mutex upgrade
+* Plugins: `Extra pack` updated and fixed (valuemutex to furi_mutex upgrade)
+* Plugins: SubGHz playlist - rewind (skip or play previous file) [(by alvarotorijano)](https://github.com/alvarotorijano/playListMod/blob/main/playlistMod.c)
+* Plugins: Properly rename unirf remix to subghz remote - And automatically migrate user files to new folder (unirf -> subghz_remote)
+* Plugins: Fix unirf freeze (protocol deserialize status ok) (by @Willy-JL | PR #375)
+* Plugins: Blackjack game: fix bug counting more than one ace (by @403-Fruit | PR #374)
+* Plugins: Update POCSAG Pager app to new error system
+* Plugins: Update iButton Fuzzer to new iButton system
+* Infrared: Update universal remote assets (by @amec0e | PR #378)
+* OFW: PicoPass: auth cleanup
+* OFW: More UI fixes and improvements
+* OFW: NFC: Support reading Mifare Classic key B from sector trailer, reading sector with B key where A key can't read block,  Nfc Magic app not using NFC folder by default (in file select) 
+* OFW: Remove ValueMutex -> **Breaking API change, api was changed from 17.x to 18.x** 
+* OFW: Support reseting iCx cards
+* OFW: Fixed picopass load save file overrun
+* OFW: Fix SD card CID parsing
+* OFW: Archive browser: update path on dir leave 
+* OFW: SubGhz: better and more verbose error handling in protocols, stricter CAME validation -> **Breaking API change, api was changed from 16.x to 17.x** 
+* OFW: iButton system and app refactoring (+new protocols) -> **Breaking API change, api was changed from 15.x to 16.x** 
 **(this will make your manually copied plugins not work, update them in same way you installed them, or delete `apps` folder and then install firmware, if you using extra pack builds (with `e` in version) all apps in _Extra will be updated automatically)**
 
-* OFW: Fix incorrect type choise condition in image compressor
-* OFW: Updater: handle storage errors when removing files, fix folder remove routine, prevent unused services from starting
-* OFW: Unify power info, power debug, and device_info into one info command
-* OFW: SD Cache: moved to diskio layer, invalidation in case of error
-* OFW: Picopass: factory key support, minor code cleanup
+* OFW: New pin reset splashscreen
+* OFW: Getter for application data path
 
 #### [🎲 Download latest extra apps pack](https://github.com/xMasterX/unleashed-extra-pack/archive/refs/heads/main.zip)
 
diff --git a/applications/debug/keypad_test/keypad_test.c b/applications/debug/keypad_test/keypad_test.c
index 2470baf8d2..9e8881defa 100644
--- a/applications/debug/keypad_test/keypad_test.c
+++ b/applications/debug/keypad_test/keypad_test.c
@@ -11,6 +11,7 @@ typedef struct {
     uint16_t left;
     uint16_t right;
     uint16_t ok;
+    FuriMutex* mutex;
 } KeypadTestState;
 
 static void keypad_test_reset_state(KeypadTestState* state) {
@@ -22,7 +23,8 @@ static void keypad_test_reset_state(KeypadTestState* state) {
 }
 
 static void keypad_test_render_callback(Canvas* canvas, void* ctx) {
-    KeypadTestState* state = (KeypadTestState*)acquire_mutex((ValueMutex*)ctx, 25);
+    KeypadTestState* state = ctx;
+    furi_mutex_acquire(state->mutex, FuriWaitForever);
     canvas_clear(canvas);
     char strings[5][20];
 
@@ -51,7 +53,7 @@ static void keypad_test_render_callback(Canvas* canvas, void* ctx) {
 
     canvas_draw_str(canvas, 10, 63, "[back] - reset, hold to exit");
 
-    release_mutex((ValueMutex*)ctx, state);
+    furi_mutex_release(state->mutex);
 }
 
 static void keypad_test_input_callback(InputEvent* input_event, void* ctx) {
@@ -64,17 +66,17 @@ int32_t keypad_test_app(void* p) {
     FuriMessageQueue* event_queue = furi_message_queue_alloc(32, sizeof(InputEvent));
     furi_check(event_queue);
 
-    KeypadTestState _state = {{false, false, false, false, false}, 0, 0, 0, 0, 0};
+    KeypadTestState state = {{false, false, false, false, false}, 0, 0, 0, 0, 0, NULL};
+    state.mutex = furi_mutex_alloc(FuriMutexTypeNormal);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, &_state, sizeof(KeypadTestState))) {
+    if(!state.mutex) {
         FURI_LOG_E(TAG, "cannot create mutex");
         return 0;
     }
 
     ViewPort* view_port = view_port_alloc();
 
-    view_port_draw_callback_set(view_port, keypad_test_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, keypad_test_render_callback, &state);
     view_port_input_callback_set(view_port, keypad_test_input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -83,7 +85,7 @@ int32_t keypad_test_app(void* p) {
 
     InputEvent event;
     while(furi_message_queue_get(event_queue, &event, FuriWaitForever) == FuriStatusOk) {
-        KeypadTestState* state = (KeypadTestState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(state.mutex, FuriWaitForever);
         FURI_LOG_I(
             TAG,
             "key: %s type: %s",
@@ -92,54 +94,54 @@ int32_t keypad_test_app(void* p) {
 
         if(event.key == InputKeyRight) {
             if(event.type == InputTypePress) {
-                state->press[0] = true;
+                state.press[0] = true;
             } else if(event.type == InputTypeRelease) {
-                state->press[0] = false;
+                state.press[0] = false;
             } else if(event.type == InputTypeShort) {
-                ++state->right;
+                ++state.right;
             }
         } else if(event.key == InputKeyLeft) {
             if(event.type == InputTypePress) {
-                state->press[1] = true;
+                state.press[1] = true;
             } else if(event.type == InputTypeRelease) {
-                state->press[1] = false;
+                state.press[1] = false;
             } else if(event.type == InputTypeShort) {
-                ++state->left;
+                ++state.left;
             }
         } else if(event.key == InputKeyUp) {
             if(event.type == InputTypePress) {
-                state->press[2] = true;
+                state.press[2] = true;
             } else if(event.type == InputTypeRelease) {
-                state->press[2] = false;
+                state.press[2] = false;
             } else if(event.type == InputTypeShort) {
-                ++state->up;
+                ++state.up;
             }
         } else if(event.key == InputKeyDown) {
             if(event.type == InputTypePress) {
-                state->press[3] = true;
+                state.press[3] = true;
             } else if(event.type == InputTypeRelease) {
-                state->press[3] = false;
+                state.press[3] = false;
             } else if(event.type == InputTypeShort) {
-                ++state->down;
+                ++state.down;
             }
         } else if(event.key == InputKeyOk) {
             if(event.type == InputTypePress) {
-                state->press[4] = true;
+                state.press[4] = true;
             } else if(event.type == InputTypeRelease) {
-                state->press[4] = false;
+                state.press[4] = false;
             } else if(event.type == InputTypeShort) {
-                ++state->ok;
+                ++state.ok;
             }
         } else if(event.key == InputKeyBack) {
             if(event.type == InputTypeLong) {
-                release_mutex(&state_mutex, state);
+                furi_mutex_release(state.mutex);
                 break;
             } else if(event.type == InputTypeShort) {
-                keypad_test_reset_state(state);
+                keypad_test_reset_state(&state);
             }
         }
 
-        release_mutex(&state_mutex, state);
+        furi_mutex_release(state.mutex);
         view_port_update(view_port);
     }
 
@@ -147,7 +149,7 @@ int32_t keypad_test_app(void* p) {
     gui_remove_view_port(gui, view_port);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(state.mutex);
 
     furi_record_close(RECORD_GUI);
 
diff --git a/applications/debug/text_box_test/text_box_test.c b/applications/debug/text_box_test/text_box_test.c
index d7194ffee4..b980f686e1 100644
--- a/applications/debug/text_box_test/text_box_test.c
+++ b/applications/debug/text_box_test/text_box_test.c
@@ -53,15 +53,17 @@ static void (*text_box_test_render[])(Canvas* canvas) = {
 
 typedef struct {
     uint32_t idx;
+    FuriMutex* mutex;
 } TextBoxTestState;
 
 static void text_box_test_render_callback(Canvas* canvas, void* ctx) {
-    TextBoxTestState* state = acquire_mutex((ValueMutex*)ctx, 25);
+    TextBoxTestState* state = ctx;
+    furi_mutex_acquire(state->mutex, FuriWaitForever);
     canvas_clear(canvas);
 
     text_box_test_render[state->idx](canvas);
 
-    release_mutex((ValueMutex*)ctx, state);
+    furi_mutex_release(state->mutex);
 }
 
 static void text_box_test_input_callback(InputEvent* input_event, void* ctx) {
@@ -74,17 +76,17 @@ int32_t text_box_test_app(void* p) {
     FuriMessageQueue* event_queue = furi_message_queue_alloc(32, sizeof(InputEvent));
     furi_check(event_queue);
 
-    TextBoxTestState _state = {.idx = 0};
+    TextBoxTestState state = {.idx = 0, .mutex = NULL};
+    state.mutex = furi_mutex_alloc(FuriMutexTypeNormal);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, &_state, sizeof(TextBoxTestState))) {
+    if(!state.mutex) {
         FURI_LOG_E(TAG, "Cannot create mutex");
         return 0;
     }
 
     ViewPort* view_port = view_port_alloc();
 
-    view_port_draw_callback_set(view_port, text_box_test_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, text_box_test_render_callback, &state);
     view_port_input_callback_set(view_port, text_box_test_input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -94,24 +96,24 @@ int32_t text_box_test_app(void* p) {
     uint32_t test_renders_num = COUNT_OF(text_box_test_render);
     InputEvent event;
     while(furi_message_queue_get(event_queue, &event, FuriWaitForever) == FuriStatusOk) {
-        TextBoxTestState* state = acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(state.mutex, FuriWaitForever);
 
         if(event.type == InputTypeShort) {
             if(event.key == InputKeyRight) {
-                if(state->idx < test_renders_num - 1) {
-                    state->idx++;
+                if(state.idx < test_renders_num - 1) {
+                    state.idx++;
                 }
             } else if(event.key == InputKeyLeft) {
-                if(state->idx > 0) {
-                    state->idx--;
+                if(state.idx > 0) {
+                    state.idx--;
                 }
             } else if(event.key == InputKeyBack) {
-                release_mutex(&state_mutex, state);
+                furi_mutex_release(state.mutex);
                 break;
             }
         }
 
-        release_mutex(&state_mutex, state);
+        furi_mutex_release(state.mutex);
         view_port_update(view_port);
     }
 
@@ -119,7 +121,7 @@ int32_t text_box_test_app(void* p) {
     gui_remove_view_port(gui, view_port);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(state.mutex);
 
     furi_record_close(RECORD_GUI);
 
diff --git a/applications/debug/unit_tests/furi/furi_test.c b/applications/debug/unit_tests/furi/furi_test.c
index eed9e42059..33ec5fd019 100644
--- a/applications/debug/unit_tests/furi/furi_test.c
+++ b/applications/debug/unit_tests/furi/furi_test.c
@@ -5,7 +5,6 @@
 
 // v2 tests
 void test_furi_create_open();
-void test_furi_valuemutex();
 void test_furi_concurrent_access();
 void test_furi_pubsub();
 
@@ -30,10 +29,6 @@ MU_TEST(mu_test_furi_create_open) {
     test_furi_create_open();
 }
 
-MU_TEST(mu_test_furi_valuemutex) {
-    test_furi_valuemutex();
-}
-
 MU_TEST(mu_test_furi_pubsub) {
     test_furi_pubsub();
 }
@@ -51,7 +46,6 @@ MU_TEST_SUITE(test_suite) {
 
     // v2 tests
     MU_RUN_TEST(mu_test_furi_create_open);
-    MU_RUN_TEST(mu_test_furi_valuemutex);
     MU_RUN_TEST(mu_test_furi_pubsub);
     MU_RUN_TEST(mu_test_furi_memmgr);
 }
diff --git a/applications/debug/unit_tests/furi/furi_valuemutex_test.c b/applications/debug/unit_tests/furi/furi_valuemutex_test.c
deleted file mode 100644
index 02fd47eeb3..0000000000
--- a/applications/debug/unit_tests/furi/furi_valuemutex_test.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <furi.h>
-
-#include "../minunit.h"
-
-void test_furi_valuemutex() {
-    const int init_value = 0xdeadbeef;
-    const int changed_value = 0x12345678;
-
-    int value = init_value;
-    bool result;
-    ValueMutex valuemutex;
-
-    // init mutex case
-    result = init_mutex(&valuemutex, &value, sizeof(value));
-    mu_assert(result, "init mutex failed");
-
-    // acquire mutex case
-    int* value_pointer = acquire_mutex(&valuemutex, 100);
-    mu_assert_pointers_eq(value_pointer, &value);
-
-    // second acquire mutex case
-    int* value_pointer_second = acquire_mutex(&valuemutex, 100);
-    mu_assert_pointers_eq(value_pointer_second, NULL);
-
-    // change value case
-    *value_pointer = changed_value;
-    mu_assert_int_eq(value, changed_value);
-
-    // release mutex case
-    result = release_mutex(&valuemutex, &value);
-    mu_assert(result, "release mutex failed");
-
-    // TODO
-    //acquire mutex blocking case
-    //write mutex blocking case
-    //read mutex blocking case
-
-    mu_check(delete_mutex(&valuemutex));
-}
diff --git a/applications/debug/unit_tests/rpc/rpc_test.c b/applications/debug/unit_tests/rpc/rpc_test.c
index 76acf6be98..329f3b7412 100644
--- a/applications/debug/unit_tests/rpc/rpc_test.c
+++ b/applications/debug/unit_tests/rpc/rpc_test.c
@@ -191,7 +191,7 @@ static void clean_directory(Storage* fs_api, const char* clean_dir) {
             size_t size = strlen(clean_dir) + strlen(name) + 1 + 1;
             char* fullname = malloc(size);
             snprintf(fullname, size, "%s/%s", clean_dir, name);
-            if(fileinfo.flags & FSF_DIRECTORY) {
+            if(file_info_is_dir(&fileinfo)) {
                 clean_directory(fs_api, fullname);
             }
             FS_Error error = storage_common_remove(fs_api, fullname);
@@ -608,9 +608,8 @@ static void test_rpc_storage_list_create_expected_list(
             }
 
             if(path_contains_only_ascii(name)) {
-                list->file[i].type = (fileinfo.flags & FSF_DIRECTORY) ?
-                                         PB_Storage_File_FileType_DIR :
-                                         PB_Storage_File_FileType_FILE;
+                list->file[i].type = file_info_is_dir(&fileinfo) ? PB_Storage_File_FileType_DIR :
+                                                                   PB_Storage_File_FileType_FILE;
                 list->file[i].size = fileinfo.size;
                 list->file[i].data = NULL;
                 /* memory free inside rpc_encode_and_send() -> pb_release() */
@@ -873,7 +872,7 @@ static void test_rpc_storage_stat_run(const char* path, uint32_t command_id) {
     if(error == FSE_OK) {
         response->which_content = PB_Main_storage_stat_response_tag;
         response->content.storage_stat_response.has_file = true;
-        response->content.storage_stat_response.file.type = (fileinfo.flags & FSF_DIRECTORY) ?
+        response->content.storage_stat_response.file.type = file_info_is_dir(&fileinfo) ?
                                                                 PB_Storage_File_FileType_DIR :
                                                                 PB_Storage_File_FileType_FILE;
         response->content.storage_stat_response.file.size = fileinfo.size;
diff --git a/applications/debug/unit_tests/storage/dirwalk_test.c b/applications/debug/unit_tests/storage/dirwalk_test.c
index 97aaa35807..e0842a7a43 100644
--- a/applications/debug/unit_tests/storage/dirwalk_test.c
+++ b/applications/debug/unit_tests/storage/dirwalk_test.c
@@ -179,7 +179,7 @@ MU_TEST_1(test_dirwalk_full, Storage* storage) {
 
     while(dir_walk_read(dir_walk, path, &fileinfo) == DirWalkOK) {
         furi_string_right(path, strlen(EXT_PATH("dirwalk/")));
-        mu_check(storage_test_paths_mark(paths, path, (fileinfo.flags & FSF_DIRECTORY)));
+        mu_check(storage_test_paths_mark(paths, path, file_info_is_dir(&fileinfo)));
     }
 
     dir_walk_free(dir_walk);
@@ -204,7 +204,7 @@ MU_TEST_1(test_dirwalk_no_recursive, Storage* storage) {
 
     while(dir_walk_read(dir_walk, path, &fileinfo) == DirWalkOK) {
         furi_string_right(path, strlen(EXT_PATH("dirwalk/")));
-        mu_check(storage_test_paths_mark(paths, path, (fileinfo.flags & FSF_DIRECTORY)));
+        mu_check(storage_test_paths_mark(paths, path, file_info_is_dir(&fileinfo)));
     }
 
     dir_walk_free(dir_walk);
@@ -219,7 +219,7 @@ static bool test_dirwalk_filter_no_folder_ext(const char* name, FileInfo* filein
     UNUSED(ctx);
 
     // only files
-    if(!(fileinfo->flags & FSF_DIRECTORY)) {
+    if(!file_info_is_dir(fileinfo)) {
         // with ".test" in name
         if(strstr(name, ".test") != NULL) {
             return true;
@@ -243,7 +243,7 @@ MU_TEST_1(test_dirwalk_filter, Storage* storage) {
 
     while(dir_walk_read(dir_walk, path, &fileinfo) == DirWalkOK) {
         furi_string_right(path, strlen(EXT_PATH("dirwalk/")));
-        mu_check(storage_test_paths_mark(paths, path, (fileinfo.flags & FSF_DIRECTORY)));
+        mu_check(storage_test_paths_mark(paths, path, file_info_is_dir(&fileinfo)));
     }
 
     dir_walk_free(dir_walk);
diff --git a/applications/debug/unit_tests/storage/storage_test.c b/applications/debug/unit_tests/storage/storage_test.c
index 115009701c..582be7902b 100644
--- a/applications/debug/unit_tests/storage/storage_test.c
+++ b/applications/debug/unit_tests/storage/storage_test.c
@@ -2,9 +2,40 @@
 #include <furi.h>
 #include <storage/storage.h>
 
+// DO NOT USE THIS IN PRODUCTION CODE
+// This is a hack to access internal storage functions and definitions
+#include <storage/storage_i.h>
+
+#define UNIT_TESTS_PATH(path) EXT_PATH("unit_tests/" path)
+
 #define STORAGE_LOCKED_FILE EXT_PATH("locked_file.test")
 #define STORAGE_LOCKED_DIR STORAGE_INT_PATH_PREFIX
 
+#define STORAGE_TEST_DIR UNIT_TESTS_PATH("test_dir")
+
+static bool storage_file_create(Storage* storage, const char* path, const char* data) {
+    File* file = storage_file_alloc(storage);
+    bool result = false;
+    do {
+        if(!storage_file_open(file, path, FSAM_WRITE, FSOM_CREATE_NEW)) {
+            break;
+        }
+
+        if(storage_file_write(file, data, strlen(data)) != strlen(data)) {
+            break;
+        }
+
+        if(!storage_file_close(file)) {
+            break;
+        }
+
+        result = true;
+    } while(0);
+
+    storage_file_free(file);
+    return result;
+}
+
 static void storage_file_open_lock_setup() {
     Storage* storage = furi_record_open(RECORD_STORAGE);
     File* file = storage_file_alloc(storage);
@@ -115,7 +146,7 @@ static int32_t storage_dir_locker(void* ctx) {
     File* file = storage_file_alloc(storage);
     furi_check(storage_dir_open(file, STORAGE_LOCKED_DIR));
     furi_semaphore_release(semaphore);
-    furi_delay_ms(1000);
+    furi_delay_ms(100);
 
     furi_check(storage_dir_close(file));
     furi_record_close(RECORD_STORAGE);
@@ -152,9 +183,21 @@ MU_TEST(storage_dir_open_lock) {
     mu_assert(result, "cannot open locked dir");
 }
 
+MU_TEST(storage_dir_exists_test) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    mu_check(!storage_dir_exists(storage, STORAGE_TEST_DIR));
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, STORAGE_TEST_DIR));
+    mu_check(storage_dir_exists(storage, STORAGE_TEST_DIR));
+    mu_assert_int_eq(FSE_OK, storage_common_remove(storage, STORAGE_TEST_DIR));
+
+    furi_record_close(RECORD_STORAGE);
+}
+
 MU_TEST_SUITE(storage_dir) {
     MU_RUN_TEST(storage_dir_open_close);
     MU_RUN_TEST(storage_dir_open_lock);
+    MU_RUN_TEST(storage_dir_exists_test);
 }
 
 static const char* const storage_copy_test_paths[] = {
@@ -303,9 +346,256 @@ MU_TEST_SUITE(storage_rename) {
     furi_record_close(RECORD_STORAGE);
 }
 
+#define APPSDATA_APP_PATH(path) APPS_DATA_PATH "/" path
+
+static const char* storage_test_apps[] = {
+    "-_twilight_-",
+    "-_rainbow_-",
+    "-_pinkie_-",
+    "-_apple_-",
+    "-_flutter_-",
+    "-_rare_-",
+};
+
+static size_t storage_test_apps_count = COUNT_OF(storage_test_apps);
+
+static int32_t storage_test_app(void* arg) {
+    UNUSED(arg);
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    storage_common_remove(storage, "/app/test");
+    int32_t ret = storage_file_create(storage, "/app/test", "test");
+    furi_record_close(RECORD_STORAGE);
+    return ret;
+}
+
+MU_TEST(test_storage_data_path_apps) {
+    for(size_t i = 0; i < storage_test_apps_count; i++) {
+        FuriThread* thread =
+            furi_thread_alloc_ex(storage_test_apps[i], 1024, storage_test_app, NULL);
+        furi_thread_set_appid(thread, storage_test_apps[i]);
+        furi_thread_start(thread);
+        furi_thread_join(thread);
+
+        mu_assert_int_eq(true, furi_thread_get_return_code(thread));
+
+        // Check if app data dir and file exists
+        Storage* storage = furi_record_open(RECORD_STORAGE);
+        FuriString* expected = furi_string_alloc();
+        furi_string_printf(expected, APPSDATA_APP_PATH("%s"), storage_test_apps[i]);
+
+        mu_check(storage_dir_exists(storage, furi_string_get_cstr(expected)));
+        furi_string_cat(expected, "/test");
+        mu_check(storage_file_exists(storage, furi_string_get_cstr(expected)));
+
+        furi_string_printf(expected, APPSDATA_APP_PATH("%s"), storage_test_apps[i]);
+        storage_simply_remove_recursive(storage, furi_string_get_cstr(expected));
+
+        furi_record_close(RECORD_STORAGE);
+
+        furi_string_free(expected);
+        furi_thread_free(thread);
+    }
+}
+
+MU_TEST(test_storage_data_path) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    File* file = storage_file_alloc(storage);
+    mu_check(storage_dir_open(file, "/app"));
+    mu_check(storage_dir_close(file));
+    storage_file_free(file);
+
+    // check that appsdata folder exists
+    mu_check(storage_dir_exists(storage, APPS_DATA_PATH));
+
+    // check that cli folder exists
+    mu_check(storage_dir_exists(storage, APPSDATA_APP_PATH("cli")));
+
+    storage_simply_remove(storage, APPSDATA_APP_PATH("cli"));
+
+    furi_record_close(RECORD_STORAGE);
+}
+
+MU_TEST(test_storage_common_migrate) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    // Setup test folders
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+
+    // Test migration from non existing
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    // Test migration from existing folder to non existing
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, UNIT_TESTS_PATH("migrate_old")));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old/file1"), "test1"));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old/file2.ext"), "test2"));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old/file3.ext.ext"), "test3"));
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file1")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file2.ext")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file3.ext.ext")));
+    mu_check(storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+
+    // Test migration from existing folder to existing folder
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, UNIT_TESTS_PATH("migrate_old")));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old/file1"), "test1"));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old/file2.ext"), "test2"));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old/file3.ext.ext"), "test3"));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file1")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file2.ext")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file3.ext.ext")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file11")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file21.ext")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new/file3.ext1.ext")));
+    mu_check(storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+
+    // Test migration from empty folder to existing file
+    // Expected result: FSE_OK, folder removed, file untouched
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, UNIT_TESTS_PATH("migrate_old")));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_new"), "test1"));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+
+    // Test migration from empty folder to existing folder
+    // Expected result: FSE_OK, old folder removed, new folder untouched
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, UNIT_TESTS_PATH("migrate_old")));
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, UNIT_TESTS_PATH("migrate_new")));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+
+    // Test migration from existing file to non existing, no extension
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old"), "test1"));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_file_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+
+    // Test migration from existing file to non existing, with extension
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old.file"), "test1"));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old.file"), UNIT_TESTS_PATH("migrate_new.file")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new.file")));
+    mu_check(!storage_file_exists(storage, UNIT_TESTS_PATH("migrate_old.file")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old.file"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new.file"));
+
+    // Test migration from existing file to existing file, no extension
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old"), "test1"));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_new"), "test2"));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_file_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new1")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new1"));
+
+    // Test migration from existing file to existing file, with extension
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old.file"), "test1"));
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_new.file"), "test2"));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old.file"), UNIT_TESTS_PATH("migrate_new.file")));
+
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new.file")));
+    mu_check(!storage_file_exists(storage, UNIT_TESTS_PATH("migrate_old.file")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new1.file")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old.file"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new.file"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new1.file"));
+
+    // Test migration from existing file to existing folder
+    mu_check(storage_file_create(storage, UNIT_TESTS_PATH("migrate_old"), "test1"));
+    mu_assert_int_eq(FSE_OK, storage_common_mkdir(storage, UNIT_TESTS_PATH("migrate_new")));
+
+    mu_assert_int_eq(
+        FSE_OK,
+        storage_common_migrate(
+            storage, UNIT_TESTS_PATH("migrate_old"), UNIT_TESTS_PATH("migrate_new")));
+
+    mu_check(storage_dir_exists(storage, UNIT_TESTS_PATH("migrate_new")));
+    mu_check(!storage_file_exists(storage, UNIT_TESTS_PATH("migrate_old")));
+    mu_check(storage_file_exists(storage, UNIT_TESTS_PATH("migrate_new1")));
+
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_old"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new"));
+    storage_simply_remove_recursive(storage, UNIT_TESTS_PATH("migrate_new1"));
+
+    furi_record_close(RECORD_STORAGE);
+}
+
+MU_TEST_SUITE(test_data_path) {
+    MU_RUN_TEST(test_storage_data_path);
+    MU_RUN_TEST(test_storage_data_path_apps);
+}
+
+MU_TEST_SUITE(test_storage_common) {
+    MU_RUN_TEST(test_storage_common_migrate);
+}
+
 int run_minunit_test_storage() {
     MU_RUN_SUITE(storage_file);
     MU_RUN_SUITE(storage_dir);
     MU_RUN_SUITE(storage_rename);
+    MU_RUN_SUITE(test_data_path);
+    MU_RUN_SUITE(test_storage_common);
     return MU_EXIT_CODE;
 }
diff --git a/applications/examples/example_apps_data/README.md b/applications/examples/example_apps_data/README.md
new file mode 100644
index 0000000000..fd86660775
--- /dev/null
+++ b/applications/examples/example_apps_data/README.md
@@ -0,0 +1,18 @@
+# Apps Data folder Example
+
+This example demonstrates how to utilize the Apps Data folder to store data that is not part of the app itself, such as user data, configuration files, and so forth.
+
+## What is the Apps Data Folder?
+
+The **Apps Data** folder is a folder used to store data for external apps that are not part of the main firmware. 
+
+The path to the current application folder is related to the `appid` of the app. The `appid` is used to identify the app in the app store and is stored in the `application.fam` file. 
+The Apps Data folder is located only on the external storage, the SD card.
+
+For example, if the `appid` of the app is `snake_game`, the path to the Apps Data folder will be `/ext/apps_data/snake_game`. But using raw paths is not recommended, because the path to the Apps Data folder can change in the future. Use the `/app` alias instead.
+
+## How to get the path to the Apps Data folder?
+
+You can use `/app` alias to get the path to the current application data folder. For example, if you want to open a file `config.txt` in the Apps Data folder, you can use the next path: `/app/config.txt`. But this way is not recommended, because even the `/app` alias can change in the future.
+
+We recommend to use the `APP_DATA_PATH` macro to get the path to the Apps Data folder. For example, if you want to open a file `config.txt` in the Apps Data folder, you can use the next path: `APP_DATA_PATH("config.txt")`.
\ No newline at end of file
diff --git a/applications/examples/example_apps_data/application.fam b/applications/examples/example_apps_data/application.fam
new file mode 100644
index 0000000000..f44dca97d9
--- /dev/null
+++ b/applications/examples/example_apps_data/application.fam
@@ -0,0 +1,9 @@
+App(
+    appid="example_apps_data",
+    name="Example: Apps Data",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="example_apps_data_main",
+    requires=["gui"],
+    stack_size=1 * 1024,
+    fap_category="Examples",
+)
diff --git a/applications/examples/example_apps_data/example_apps_data.c b/applications/examples/example_apps_data/example_apps_data.c
new file mode 100644
index 0000000000..d6104c1374
--- /dev/null
+++ b/applications/examples/example_apps_data/example_apps_data.c
@@ -0,0 +1,40 @@
+#include <furi.h>
+#include <storage/storage.h>
+
+// Define log tag
+#define TAG "example_apps_data"
+
+// Application entry point
+int32_t example_apps_data_main(void* p) {
+    // Mark argument as unused
+    UNUSED(p);
+
+    // Open storage
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    // Allocate file
+    File* file = storage_file_alloc(storage);
+
+    // Get the path to the current application data folder
+    // That is: /ext/apps_data/<app_name>
+    // And it will create folders in the path if they don't exist
+    // In this example it will create /ext/apps_data/example_apps_data
+    // And file will be /ext/apps_data/example_apps_data/test.txt
+
+    // Open file, write data and close it
+    if(!storage_file_open(file, APP_DATA_PATH("test.txt"), FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
+        FURI_LOG_E(TAG, "Failed to open file");
+    }
+    if(!storage_file_write(file, "Hello World!", strlen("Hello World!"))) {
+        FURI_LOG_E(TAG, "Failed to write to file");
+    }
+    storage_file_close(file);
+
+    // Deallocate file
+    storage_file_free(file);
+
+    // Close storage
+    furi_record_close(RECORD_STORAGE);
+
+    return 0;
+}
diff --git a/applications/main/application.fam b/applications/main/application.fam
index a3d3100938..1b18a7d2d4 100644
--- a/applications/main/application.fam
+++ b/applications/main/application.fam
@@ -14,7 +14,7 @@ App(
         "fap_loader",
         "archive",
         "clock",
-        "unirfremix",
+        "subghz_remote",
     ],
 )
 
diff --git a/applications/main/archive/helpers/archive_browser.c b/applications/main/archive/helpers/archive_browser.c
index c72220c6a4..f93d9694d8 100644
--- a/applications/main/archive/helpers/archive_browser.c
+++ b/applications/main/archive/helpers/archive_browser.c
@@ -451,7 +451,7 @@ static bool archive_is_dir_exists(FuriString* path) {
     FileInfo file_info;
     Storage* storage = furi_record_open(RECORD_STORAGE);
     if(storage_common_stat(storage, furi_string_get_cstr(path), &file_info) == FSE_OK) {
-        if(file_info.flags & FSF_DIRECTORY) {
+        if(file_info_is_dir(&file_info)) {
             state = true;
         }
     }
@@ -532,12 +532,16 @@ void archive_enter_dir(ArchiveBrowserView* browser, FuriString* path) {
         browser->view, ArchiveBrowserViewModel * model, { idx_temp = model->item_idx; }, false);
 
     furi_string_set(browser->path, path);
+
     file_browser_worker_folder_enter(browser->worker, path, idx_temp);
 }
 
 void archive_leave_dir(ArchiveBrowserView* browser) {
     furi_assert(browser);
 
+    size_t dirname_start = furi_string_search_rchar(browser->path, '/');
+    furi_string_left(browser->path, dirname_start);
+
     file_browser_worker_folder_exit(browser->worker);
 }
 
diff --git a/applications/main/archive/helpers/archive_favorites.c b/applications/main/archive/helpers/archive_favorites.c
index 8bbcb52136..f395ee5a11 100644
--- a/applications/main/archive/helpers/archive_favorites.c
+++ b/applications/main/archive/helpers/archive_favorites.c
@@ -160,7 +160,7 @@ bool archive_favorites_read(void* context) {
                 if(storage_file_exists(storage, furi_string_get_cstr(buffer))) {
                     storage_common_stat(storage, furi_string_get_cstr(buffer), &file_info);
                     archive_add_file_item(
-                        browser, (file_info.flags & FSF_DIRECTORY), furi_string_get_cstr(buffer));
+                        browser, file_info_is_dir(&file_info), furi_string_get_cstr(buffer));
                     file_count++;
                 } else {
                     need_refresh = true;
diff --git a/applications/main/archive/helpers/archive_files.c b/applications/main/archive/helpers/archive_files.c
index 5c06c1bdad..8aef0ef09a 100644
--- a/applications/main/archive/helpers/archive_files.c
+++ b/applications/main/archive/helpers/archive_files.c
@@ -96,7 +96,7 @@ void archive_delete_file(void* context, const char* format, ...) {
 
     bool res = false;
 
-    if(fileinfo.flags & FSF_DIRECTORY) {
+    if(file_info_is_dir(&fileinfo)) {
         res = storage_simply_remove_recursive(fs_api, furi_string_get_cstr(filename));
     } else {
         res = (storage_common_remove(fs_api, furi_string_get_cstr(filename)) == FSE_OK);
diff --git a/applications/main/bad_usb/scenes/bad_usb_scene_config.c b/applications/main/bad_usb/scenes/bad_usb_scene_config.c
index 2a9f2f76c9..c88cae0324 100644
--- a/applications/main/bad_usb/scenes/bad_usb_scene_config.c
+++ b/applications/main/bad_usb/scenes/bad_usb_scene_config.c
@@ -17,7 +17,7 @@ void bad_usb_scene_config_on_enter(void* context) {
 
     submenu_add_item(
         submenu,
-        "Keyboard layout",
+        "Keyboard Layout",
         SubmenuIndexKeyboardLayout,
         bad_usb_scene_config_submenu_callback,
         bad_usb);
diff --git a/applications/main/fap_loader/fap_loader_app.c b/applications/main/fap_loader/fap_loader_app.c
index 7911aa0689..e81a3ce4c8 100644
--- a/applications/main/fap_loader/fap_loader_app.c
+++ b/applications/main/fap_loader/fap_loader_app.c
@@ -5,6 +5,7 @@
 #include <storage/storage.h>
 #include <gui/modules/loading.h>
 #include <dialogs/dialogs.h>
+#include <toolbox/path.h>
 #include <flipper_application/flipper_application.h>
 #include "elf_cpp/elf_hashtable.h"
 #include "fap_loader_app.h"
@@ -105,6 +106,12 @@ static bool fap_loader_run_selected_app(FapLoader* loader) {
         FURI_LOG_I(TAG, "FAP Loader is starting app");
 
         FuriThread* thread = flipper_application_spawn(loader->app, NULL);
+
+        FuriString* app_name = furi_string_alloc();
+        path_extract_filename_no_ext(furi_string_get_cstr(loader->fap_path), app_name);
+        furi_thread_set_appid(thread, furi_string_get_cstr(app_name));
+        furi_string_free(app_name);
+
         furi_thread_start(thread);
         furi_thread_join(thread);
 
diff --git a/applications/main/ibutton/ibutton.c b/applications/main/ibutton/ibutton.c
index 85212f42b6..79999adb28 100644
--- a/applications/main/ibutton/ibutton.c
+++ b/applications/main/ibutton/ibutton.c
@@ -1,10 +1,6 @@
-#include "ibutton.h"
-#include "assets_icons.h"
 #include "ibutton_i.h"
-#include "ibutton/scenes/ibutton_scene.h"
+
 #include <toolbox/path.h>
-#include <flipper_format/flipper_format.h>
-#include <rpc/rpc_app.h>
 #include <dolphin/dolphin.h>
 
 #define TAG "iButtonApp"
@@ -34,50 +30,13 @@ static const NotificationSequence* ibutton_notification_sequences[] = {
 };
 
 static void ibutton_make_app_folder(iButton* ibutton) {
-    if(!storage_simply_mkdir(ibutton->storage, IBUTTON_APP_FOLDER)) {
-        dialog_message_show_storage_error(ibutton->dialogs, "Cannot create\napp folder");
-    }
-}
-
-bool ibutton_load_key_data(iButton* ibutton, FuriString* key_path, bool show_dialog) {
-    FlipperFormat* file = flipper_format_file_alloc(ibutton->storage);
-    bool result = false;
-    FuriString* data;
-    data = furi_string_alloc();
-
-    do {
-        if(!flipper_format_file_open_existing(file, furi_string_get_cstr(key_path))) break;
-
-        // header
-        uint32_t version;
-        if(!flipper_format_read_header(file, data, &version)) break;
-        if(furi_string_cmp_str(data, IBUTTON_APP_FILE_TYPE) != 0) break;
-        if(version != 1) break;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
 
-        // key type
-        iButtonKeyType type;
-        if(!flipper_format_read_string(file, "Key type", data)) break;
-        if(!ibutton_key_get_type_by_string(furi_string_get_cstr(data), &type)) break;
-
-        // key data
-        uint8_t key_data[IBUTTON_KEY_DATA_SIZE] = {0};
-        if(!flipper_format_read_hex(file, "Data", key_data, ibutton_key_get_size_by_type(type)))
-            break;
-
-        ibutton_key_set_type(ibutton->key, type);
-        ibutton_key_set_data(ibutton->key, key_data, IBUTTON_KEY_DATA_SIZE);
-
-        result = true;
-    } while(false);
-
-    flipper_format_free(file);
-    furi_string_free(data);
-
-    if((!result) && (show_dialog)) {
-        dialog_message_show_storage_error(ibutton->dialogs, "Cannot load\nkey file");
+    if(!storage_simply_mkdir(storage, IBUTTON_APP_FOLDER)) {
+        dialog_message_show_storage_error(ibutton->dialogs, "Cannot create\napp folder");
     }
 
-    return result;
+    furi_record_close(RECORD_STORAGE);
 }
 
 static void ibutton_rpc_command_callback(RpcAppSystemEvent event, void* context) {
@@ -87,14 +46,14 @@ static void ibutton_rpc_command_callback(RpcAppSystemEvent event, void* context)
     if(event == RpcAppEventSessionClose) {
         view_dispatcher_send_custom_event(
             ibutton->view_dispatcher, iButtonCustomEventRpcSessionClose);
-        rpc_system_app_set_callback(ibutton->rpc_ctx, NULL, NULL);
-        ibutton->rpc_ctx = NULL;
+        rpc_system_app_set_callback(ibutton->rpc, NULL, NULL);
+        ibutton->rpc = NULL;
     } else if(event == RpcAppEventAppExit) {
         view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcExit);
     } else if(event == RpcAppEventLoadFile) {
         view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventRpcLoad);
     } else {
-        rpc_system_app_confirm(ibutton->rpc_ctx, event, false);
+        rpc_system_app_confirm(ibutton->rpc, event, false);
     }
 }
 
@@ -135,13 +94,13 @@ iButton* ibutton_alloc() {
 
     ibutton->gui = furi_record_open(RECORD_GUI);
 
-    ibutton->storage = furi_record_open(RECORD_STORAGE);
     ibutton->dialogs = furi_record_open(RECORD_DIALOGS);
     ibutton->notifications = furi_record_open(RECORD_NOTIFICATION);
 
-    ibutton->key = ibutton_key_alloc();
-    ibutton->key_worker = ibutton_worker_alloc();
-    ibutton_worker_start_thread(ibutton->key_worker);
+    ibutton->protocols = ibutton_protocols_alloc();
+    ibutton->key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(ibutton->protocols));
+    ibutton->worker = ibutton_worker_alloc(ibutton->protocols);
+    ibutton_worker_start_thread(ibutton->worker);
 
     ibutton->submenu = submenu_alloc();
     view_dispatcher_add_view(
@@ -163,9 +122,9 @@ iButton* ibutton_alloc() {
     view_dispatcher_add_view(
         ibutton->view_dispatcher, iButtonViewWidget, widget_get_view(ibutton->widget));
 
-    ibutton->dialog_ex = dialog_ex_alloc();
+    ibutton->loading = loading_alloc();
     view_dispatcher_add_view(
-        ibutton->view_dispatcher, iButtonViewDialogEx, dialog_ex_get_view(ibutton->dialog_ex));
+        ibutton->view_dispatcher, iButtonViewLoading, loading_get_view(ibutton->loading));
 
     return ibutton;
 }
@@ -173,8 +132,8 @@ iButton* ibutton_alloc() {
 void ibutton_free(iButton* ibutton) {
     furi_assert(ibutton);
 
-    view_dispatcher_remove_view(ibutton->view_dispatcher, iButtonViewDialogEx);
-    dialog_ex_free(ibutton->dialog_ex);
+    view_dispatcher_remove_view(ibutton->view_dispatcher, iButtonViewLoading);
+    loading_free(ibutton->loading);
 
     view_dispatcher_remove_view(ibutton->view_dispatcher, iButtonViewWidget);
     widget_free(ibutton->widget);
@@ -194,9 +153,6 @@ void ibutton_free(iButton* ibutton) {
     view_dispatcher_free(ibutton->view_dispatcher);
     scene_manager_free(ibutton->scene_manager);
 
-    furi_record_close(RECORD_STORAGE);
-    ibutton->storage = NULL;
-
     furi_record_close(RECORD_NOTIFICATION);
     ibutton->notifications = NULL;
 
@@ -206,103 +162,83 @@ void ibutton_free(iButton* ibutton) {
     furi_record_close(RECORD_GUI);
     ibutton->gui = NULL;
 
-    ibutton_worker_stop_thread(ibutton->key_worker);
-    ibutton_worker_free(ibutton->key_worker);
+    ibutton_worker_stop_thread(ibutton->worker);
+    ibutton_worker_free(ibutton->worker);
     ibutton_key_free(ibutton->key);
+    ibutton_protocols_free(ibutton->protocols);
 
     furi_string_free(ibutton->file_path);
 
     free(ibutton);
 }
 
-bool ibutton_file_select(iButton* ibutton) {
-    DialogsFileBrowserOptions browser_options;
-    dialog_file_browser_set_basic_options(&browser_options, IBUTTON_APP_EXTENSION, &I_ibutt_10px);
-    browser_options.base_path = IBUTTON_APP_FOLDER;
-
-    bool success = dialog_file_browser_show(
-        ibutton->dialogs, ibutton->file_path, ibutton->file_path, &browser_options);
+bool ibutton_load_key(iButton* ibutton) {
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewLoading);
 
-    if(success) {
-        success = ibutton_load_key_data(ibutton, ibutton->file_path, true);
-    }
-
-    return success;
-}
-
-bool ibutton_save_key(iButton* ibutton, const char* key_name) {
-    // Create ibutton directory if necessary
-    ibutton_make_app_folder(ibutton);
-
-    FlipperFormat* file = flipper_format_file_alloc(ibutton->storage);
-    iButtonKey* key = ibutton->key;
+    const bool success = ibutton_protocols_load(
+        ibutton->protocols, ibutton->key, furi_string_get_cstr(ibutton->file_path));
 
-    bool result = false;
+    if(!success) {
+        dialog_message_show_storage_error(ibutton->dialogs, "Cannot load\nkey file");
 
-    do {
-        // Check if we has old key
-        if(furi_string_end_with(ibutton->file_path, IBUTTON_APP_EXTENSION)) {
-            // First remove old key
-            ibutton_delete_key(ibutton);
+    } else {
+        FuriString* tmp = furi_string_alloc();
 
-            // Remove old key name from path
-            size_t filename_start = furi_string_search_rchar(ibutton->file_path, '/');
-            furi_string_left(ibutton->file_path, filename_start);
-        }
+        path_extract_filename(ibutton->file_path, tmp, true);
+        strncpy(ibutton->key_name, furi_string_get_cstr(tmp), IBUTTON_KEY_NAME_SIZE);
 
-        furi_string_cat_printf(ibutton->file_path, "/%s%s", key_name, IBUTTON_APP_EXTENSION);
+        furi_string_free(tmp);
+    }
 
-        // Open file for write
-        if(!flipper_format_file_open_always(file, furi_string_get_cstr(ibutton->file_path))) break;
+    return success;
+}
 
-        // Write header
-        if(!flipper_format_write_header_cstr(file, IBUTTON_APP_FILE_TYPE, 1)) break;
+bool ibutton_select_and_load_key(iButton* ibutton) {
+    DialogsFileBrowserOptions browser_options;
+    dialog_file_browser_set_basic_options(&browser_options, IBUTTON_APP_EXTENSION, &I_ibutt_10px);
+    browser_options.base_path = IBUTTON_APP_FOLDER;
 
-        // Write key type
-        if(!flipper_format_write_comment_cstr(file, "Key type can be Cyfral, Dallas or Metakom"))
-            break;
-        const char* key_type = ibutton_key_get_string_by_type(ibutton_key_get_type(key));
-        if(!flipper_format_write_string_cstr(file, "Key type", key_type)) break;
+    if(furi_string_empty(ibutton->file_path)) {
+        furi_string_set(ibutton->file_path, browser_options.base_path);
+    }
 
-        // Write data
-        if(!flipper_format_write_comment_cstr(
-               file, "Data size for Cyfral is 2, for Metakom is 4, for Dallas is 8"))
-            break;
+    return dialog_file_browser_show(
+               ibutton->dialogs, ibutton->file_path, ibutton->file_path, &browser_options) &&
+           ibutton_load_key(ibutton);
+}
 
-        if(!flipper_format_write_hex(
-               file, "Data", ibutton_key_get_data_p(key), ibutton_key_get_data_size(key)))
-            break;
-        result = true;
+bool ibutton_save_key(iButton* ibutton) {
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewLoading);
 
-    } while(false);
+    ibutton_make_app_folder(ibutton);
 
-    flipper_format_free(file);
+    iButtonKey* key = ibutton->key;
+    const bool success =
+        ibutton_protocols_save(ibutton->protocols, key, furi_string_get_cstr(ibutton->file_path));
 
-    if(!result) { //-V547
+    if(!success) {
         dialog_message_show_storage_error(ibutton->dialogs, "Cannot save\nkey file");
     }
 
-    return result;
+    return success;
 }
 
 bool ibutton_delete_key(iButton* ibutton) {
     bool result = false;
-    result = storage_simply_remove(ibutton->storage, furi_string_get_cstr(ibutton->file_path));
 
-    return result;
-}
-
-void ibutton_text_store_set(iButton* ibutton, const char* text, ...) {
-    va_list args;
-    va_start(args, text);
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    result = storage_simply_remove(storage, furi_string_get_cstr(ibutton->file_path));
+    furi_record_close(RECORD_STORAGE);
 
-    vsnprintf(ibutton->text_store, IBUTTON_TEXT_STORE_SIZE, text, args);
+    ibutton_reset_key(ibutton);
 
-    va_end(args);
+    return result;
 }
 
-void ibutton_text_store_clear(iButton* ibutton) {
-    memset(ibutton->text_store, 0, IBUTTON_TEXT_STORE_SIZE + 1);
+void ibutton_reset_key(iButton* ibutton) {
+    memset(ibutton->key_name, 0, IBUTTON_KEY_NAME_SIZE + 1);
+    furi_string_reset(ibutton->file_path);
+    ibutton_key_reset(ibutton->key);
 }
 
 void ibutton_notification_message(iButton* ibutton, uint32_t message) {
@@ -310,36 +246,44 @@ void ibutton_notification_message(iButton* ibutton, uint32_t message) {
     notification_message(ibutton->notifications, ibutton_notification_sequences[message]);
 }
 
-int32_t ibutton_app(void* p) {
+void ibutton_submenu_callback(void* context, uint32_t index) {
+    iButton* ibutton = context;
+    view_dispatcher_send_custom_event(ibutton->view_dispatcher, index);
+}
+
+void ibutton_widget_callback(GuiButtonType result, InputType type, void* context) {
+    iButton* ibutton = context;
+    if(type == InputTypeShort) {
+        view_dispatcher_send_custom_event(ibutton->view_dispatcher, result);
+    }
+}
+
+int32_t ibutton_app(void* arg) {
     iButton* ibutton = ibutton_alloc();
 
     ibutton_make_app_folder(ibutton);
 
     bool key_loaded = false;
-    bool rpc_mode = false;
 
-    if(p && strlen(p)) {
-        uint32_t rpc_ctx = 0;
-        if(sscanf(p, "RPC %lX", &rpc_ctx) == 1) {
+    if((arg != NULL) && (strlen(arg) != 0)) {
+        if(sscanf(arg, "RPC %lX", (uint32_t*)&ibutton->rpc) == 1) {
             FURI_LOG_D(TAG, "Running in RPC mode");
-            ibutton->rpc_ctx = (void*)rpc_ctx;
-            rpc_mode = true;
-            rpc_system_app_set_callback(ibutton->rpc_ctx, ibutton_rpc_command_callback, ibutton);
-            rpc_system_app_send_started(ibutton->rpc_ctx);
+
+            rpc_system_app_set_callback(ibutton->rpc, ibutton_rpc_command_callback, ibutton);
+            rpc_system_app_send_started(ibutton->rpc);
+
         } else {
-            furi_string_set(ibutton->file_path, (const char*)p);
-            if(ibutton_load_key_data(ibutton, ibutton->file_path, true)) {
-                key_loaded = true;
-                // TODO: Display an error if the key from p could not be loaded
-            }
+            furi_string_set(ibutton->file_path, (const char*)arg);
+            key_loaded = ibutton_load_key(ibutton);
         }
     }
 
-    if(rpc_mode) {
+    if(ibutton->rpc != NULL) {
         view_dispatcher_attach_to_gui(
             ibutton->view_dispatcher, ibutton->gui, ViewDispatcherTypeDesktop);
         scene_manager_next_scene(ibutton->scene_manager, iButtonSceneRpc);
         DOLPHIN_DEED(DolphinDeedIbuttonEmulate);
+
     } else {
         view_dispatcher_attach_to_gui(
             ibutton->view_dispatcher, ibutton->gui, ViewDispatcherTypeFullscreen);
@@ -353,9 +297,9 @@ int32_t ibutton_app(void* p) {
 
     view_dispatcher_run(ibutton->view_dispatcher);
 
-    if(ibutton->rpc_ctx) {
-        rpc_system_app_set_callback(ibutton->rpc_ctx, NULL, NULL);
-        rpc_system_app_send_exited(ibutton->rpc_ctx);
+    if(ibutton->rpc) {
+        rpc_system_app_set_callback(ibutton->rpc, NULL, NULL);
+        rpc_system_app_send_exited(ibutton->rpc);
     }
     ibutton_free(ibutton);
     return 0;
diff --git a/applications/main/ibutton/ibutton_cli.c b/applications/main/ibutton/ibutton_cli.c
index 9ddb079dc9..2b88b20076 100644
--- a/applications/main/ibutton/ibutton_cli.c
+++ b/applications/main/ibutton/ibutton_cli.c
@@ -1,11 +1,15 @@
 #include <furi.h>
 #include <furi_hal.h>
-#include <stdarg.h>
+
 #include <cli/cli.h>
-#include <lib/toolbox/args.h>
-#include <one_wire/ibutton/ibutton_worker.h>
+#include <toolbox/args.h>
+
 #include <one_wire/one_wire_host.h>
 
+#include <one_wire/ibutton/ibutton_key.h>
+#include <one_wire/ibutton/ibutton_worker.h>
+#include <one_wire/ibutton/ibutton_protocols.h>
+
 static void ibutton_cli(Cli* cli, FuriString* args, void* context);
 static void onewire_cli(Cli* cli, FuriString* args, void* context);
 
@@ -22,7 +26,7 @@ void ibutton_on_system_start() {
 #endif
 }
 
-void ibutton_cli_print_usage() {
+static void ibutton_cli_print_usage() {
     printf("Usage:\r\n");
     printf("ikey read\r\n");
     printf("ikey emulate <key_type> <key_data>\r\n");
@@ -34,30 +38,52 @@ void ibutton_cli_print_usage() {
     printf("\t<key_data> are hex-formatted\r\n");
 };
 
-bool ibutton_cli_get_key_type(FuriString* data, iButtonKeyType* type) {
+static bool ibutton_cli_parse_key(iButtonProtocols* protocols, iButtonKey* key, FuriString* args) {
     bool result = false;
+    FuriString* name = furi_string_alloc();
+
+    do {
+        // Read protocol name
+        if(!args_read_string_and_trim(args, name)) break;
+
+        // Make the protocol name uppercase
+        const char first = furi_string_get_char(name, 0);
+        furi_string_set_char(name, 0, toupper((int)first));
+
+        const iButtonProtocolId id =
+            ibutton_protocols_get_id_by_name(protocols, furi_string_get_cstr(name));
+        if(id == iButtonProtocolIdInvalid) break;
+
+        ibutton_key_set_protocol_id(key, id);
+
+        // Get the data pointer
+        iButtonEditableData data;
+        ibutton_protocols_get_editable_data(protocols, key, &data);
+
+        // Read data
+        if(!args_read_hex_bytes(args, data.ptr, data.size)) break;
 
-    if(furi_string_cmp_str(data, "Dallas") == 0 || furi_string_cmp_str(data, "dallas") == 0) {
-        result = true;
-        *type = iButtonKeyDS1990;
-    } else if(furi_string_cmp_str(data, "Cyfral") == 0 || furi_string_cmp_str(data, "cyfral") == 0) {
-        result = true;
-        *type = iButtonKeyCyfral;
-    } else if(furi_string_cmp_str(data, "Metakom") == 0 || furi_string_cmp_str(data, "metakom") == 0) {
         result = true;
-        *type = iButtonKeyMetakom;
-    }
+    } while(false);
 
+    furi_string_free(name);
     return result;
 }
 
-void ibutton_cli_print_key_data(iButtonKey* key) {
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
-    iButtonKeyType type = ibutton_key_get_type(key);
+static void ibutton_cli_print_key(iButtonProtocols* protocols, iButtonKey* key) {
+    const char* name = ibutton_protocols_get_name(protocols, ibutton_key_get_protocol_id(key));
 
-    printf("%s ", ibutton_key_get_string_by_type(type));
-    for(size_t i = 0; i < ibutton_key_get_size_by_type(type); i++) {
-        printf("%02X", key_data[i]);
+    if(strncmp(name, "DS", 2) == 0) {
+        name = "Dallas";
+    }
+
+    printf("%s ", name);
+
+    iButtonEditableData data;
+    ibutton_protocols_get_editable_data(protocols, key, &data);
+
+    for(size_t i = 0; i < data.size; i++) {
+        printf("%02X", data.ptr[i]);
     }
 
     printf("\r\n");
@@ -71,9 +97,10 @@ static void ibutton_cli_worker_read_cb(void* context) {
     furi_event_flag_set(event, EVENT_FLAG_IBUTTON_COMPLETE);
 }
 
-void ibutton_cli_read(Cli* cli) {
-    iButtonKey* key = ibutton_key_alloc();
-    iButtonWorker* worker = ibutton_worker_alloc();
+static void ibutton_cli_read(Cli* cli) {
+    iButtonProtocols* protocols = ibutton_protocols_alloc();
+    iButtonWorker* worker = ibutton_worker_alloc(protocols);
+    iButtonKey* key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(protocols));
     FuriEventFlag* event = furi_event_flag_alloc();
 
     ibutton_worker_start_thread(worker);
@@ -81,32 +108,25 @@ void ibutton_cli_read(Cli* cli) {
 
     printf("Reading iButton...\r\nPress Ctrl+C to abort\r\n");
     ibutton_worker_read_start(worker, key);
+
     while(true) {
         uint32_t flags =
             furi_event_flag_wait(event, EVENT_FLAG_IBUTTON_COMPLETE, FuriFlagWaitAny, 100);
 
         if(flags & EVENT_FLAG_IBUTTON_COMPLETE) {
-            ibutton_cli_print_key_data(key);
-
-            if(ibutton_key_get_type(key) == iButtonKeyDS1990) {
-                if(!ibutton_key_dallas_crc_is_valid(key)) {
-                    printf("Warning: invalid CRC\r\n");
-                }
-
-                if(!ibutton_key_dallas_is_1990_key(key)) {
-                    printf("Warning: not a key\r\n");
-                }
-            }
+            ibutton_cli_print_key(protocols, key);
             break;
         }
 
         if(cli_cmd_interrupt_received(cli)) break;
     }
-    ibutton_worker_stop(worker);
 
+    ibutton_worker_stop(worker);
     ibutton_worker_stop_thread(worker);
-    ibutton_worker_free(worker);
+
     ibutton_key_free(key);
+    ibutton_worker_free(worker);
+    ibutton_protocols_free(protocols);
 
     furi_event_flag_free(event);
 };
@@ -124,48 +144,33 @@ static void ibutton_cli_worker_write_cb(void* context, iButtonWorkerWriteResult
 }
 
 void ibutton_cli_write(Cli* cli, FuriString* args) {
-    iButtonKey* key = ibutton_key_alloc();
-    iButtonWorker* worker = ibutton_worker_alloc();
-    iButtonKeyType type;
-    iButtonWriteContext write_context;
-    uint8_t key_data[IBUTTON_KEY_DATA_SIZE];
-    FuriString* data;
+    iButtonProtocols* protocols = ibutton_protocols_alloc();
+    iButtonWorker* worker = ibutton_worker_alloc(protocols);
+    iButtonKey* key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(protocols));
 
+    iButtonWriteContext write_context;
     write_context.event = furi_event_flag_alloc();
 
-    data = furi_string_alloc();
     ibutton_worker_start_thread(worker);
     ibutton_worker_write_set_callback(worker, ibutton_cli_worker_write_cb, &write_context);
 
     do {
-        if(!args_read_string_and_trim(args, data)) {
-            ibutton_cli_print_usage();
-            break;
-        }
-
-        if(!ibutton_cli_get_key_type(data, &type)) {
-            ibutton_cli_print_usage();
-            break;
-        }
-
-        if(type != iButtonKeyDS1990) {
+        if(!ibutton_cli_parse_key(protocols, key, args)) {
             ibutton_cli_print_usage();
             break;
         }
 
-        if(!args_read_hex_bytes(args, key_data, ibutton_key_get_size_by_type(type))) {
+        if(!(ibutton_protocols_get_features(protocols, ibutton_key_get_protocol_id(key)) &
+             iButtonProtocolFeatureWriteBlank)) {
             ibutton_cli_print_usage();
             break;
         }
 
-        ibutton_key_set_type(key, type);
-        ibutton_key_set_data(key, key_data, ibutton_key_get_size_by_type(type));
-
         printf("Writing key ");
-        ibutton_cli_print_key_data(key);
+        ibutton_cli_print_key(protocols, key);
         printf("Press Ctrl+C to abort\r\n");
 
-        ibutton_worker_write_start(worker, key);
+        ibutton_worker_write_blank_start(worker, key);
         while(true) {
             uint32_t flags = furi_event_flag_wait(
                 write_context.event, EVENT_FLAG_IBUTTON_COMPLETE, FuriFlagWaitAny, 100);
@@ -183,64 +188,53 @@ void ibutton_cli_write(Cli* cli, FuriString* args) {
 
             if(cli_cmd_interrupt_received(cli)) break;
         }
-        ibutton_worker_stop(worker);
     } while(false);
 
-    furi_string_free(data);
+    ibutton_worker_stop(worker);
     ibutton_worker_stop_thread(worker);
-    ibutton_worker_free(worker);
+
     ibutton_key_free(key);
+    ibutton_worker_free(worker);
+    ibutton_protocols_free(protocols);
 
     furi_event_flag_free(write_context.event);
-};
+}
 
 void ibutton_cli_emulate(Cli* cli, FuriString* args) {
-    iButtonKey* key = ibutton_key_alloc();
-    iButtonWorker* worker = ibutton_worker_alloc();
-    iButtonKeyType type;
-    uint8_t key_data[IBUTTON_KEY_DATA_SIZE];
-    FuriString* data;
+    iButtonProtocols* protocols = ibutton_protocols_alloc();
+    iButtonWorker* worker = ibutton_worker_alloc(protocols);
+    iButtonKey* key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(protocols));
 
-    data = furi_string_alloc();
     ibutton_worker_start_thread(worker);
 
     do {
-        if(!args_read_string_and_trim(args, data)) {
+        if(!ibutton_cli_parse_key(protocols, key, args)) {
             ibutton_cli_print_usage();
             break;
         }
 
-        if(!ibutton_cli_get_key_type(data, &type)) {
-            ibutton_cli_print_usage();
-            break;
-        }
-
-        if(!args_read_hex_bytes(args, key_data, ibutton_key_get_size_by_type(type))) {
-            ibutton_cli_print_usage();
-            break;
-        }
-
-        ibutton_key_set_type(key, type);
-        ibutton_key_set_data(key, key_data, ibutton_key_get_size_by_type(type));
-
         printf("Emulating key ");
-        ibutton_cli_print_key_data(key);
+        ibutton_cli_print_key(protocols, key);
         printf("Press Ctrl+C to abort\r\n");
 
         ibutton_worker_emulate_start(worker, key);
+
         while(!cli_cmd_interrupt_received(cli)) {
             furi_delay_ms(100);
         };
-        ibutton_worker_stop(worker);
+
     } while(false);
 
-    furi_string_free(data);
+    ibutton_worker_stop(worker);
     ibutton_worker_stop_thread(worker);
-    ibutton_worker_free(worker);
+
     ibutton_key_free(key);
+    ibutton_worker_free(worker);
+    ibutton_protocols_free(protocols);
 };
 
-static void ibutton_cli(Cli* cli, FuriString* args, void* context) {
+void ibutton_cli(Cli* cli, FuriString* args, void* context) {
+    UNUSED(cli);
     UNUSED(context);
     FuriString* cmd;
     cmd = furi_string_alloc();
@@ -264,7 +258,7 @@ static void ibutton_cli(Cli* cli, FuriString* args, void* context) {
     furi_string_free(cmd);
 }
 
-void onewire_cli_print_usage() {
+static void onewire_cli_print_usage() {
     printf("Usage:\r\n");
     printf("onewire search\r\n");
 };
@@ -281,7 +275,7 @@ static void onewire_cli_search(Cli* cli) {
     furi_hal_power_enable_otg();
 
     while(!done) {
-        if(onewire_host_search(onewire, address, NORMAL_SEARCH) != 1) {
+        if(onewire_host_search(onewire, address, OneWireHostSearchModeNormal) != 1) {
             printf("Search finished\r\n");
             onewire_host_reset_search(onewire);
             done = true;
diff --git a/applications/main/ibutton/ibutton_custom_event.h b/applications/main/ibutton/ibutton_custom_event.h
index 1e2f0300dc..28bcb94a0d 100644
--- a/applications/main/ibutton/ibutton_custom_event.h
+++ b/applications/main/ibutton/ibutton_custom_event.h
@@ -6,6 +6,7 @@ enum iButtonCustomEvent {
 
     iButtonCustomEventBack,
     iButtonCustomEventTextEditResult,
+    iButtonCustomEventByteEditChanged,
     iButtonCustomEventByteEditResult,
     iButtonCustomEventWorkerEmulated,
     iButtonCustomEventWorkerRead,
diff --git a/applications/main/ibutton/ibutton_i.h b/applications/main/ibutton/ibutton_i.h
index 0a80993517..8ad0b90e4a 100644
--- a/applications/main/ibutton/ibutton_i.h
+++ b/applications/main/ibutton/ibutton_i.h
@@ -4,31 +4,40 @@
 
 #include <gui/gui.h>
 #include <gui/view.h>
-#include <assets_icons.h>
-#include <gui/view_dispatcher.h>
 #include <gui/scene_manager.h>
-#include <notification/notification_messages.h>
+#include <gui/view_dispatcher.h>
 
 #include <one_wire/ibutton/ibutton_worker.h>
+#include <one_wire/ibutton/ibutton_protocols.h>
+
+#include <rpc/rpc_app.h>
 #include <storage/storage.h>
 #include <dialogs/dialogs.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
 
 #include <gui/modules/submenu.h>
 #include <gui/modules/popup.h>
-#include <gui/modules/dialog_ex.h>
 #include <gui/modules/text_input.h>
 #include <gui/modules/byte_input.h>
 #include <gui/modules/widget.h>
+#include <gui/modules/loading.h>
+
+#include <assets_icons.h>
 
 #include "ibutton_custom_event.h"
 #include "scenes/ibutton_scene.h"
 
-#define IBUTTON_FILE_NAME_SIZE 100
-#define IBUTTON_TEXT_STORE_SIZE 128
-
 #define IBUTTON_APP_FOLDER ANY_PATH("ibutton")
 #define IBUTTON_APP_EXTENSION ".ibtn"
-#define IBUTTON_APP_FILE_TYPE "Flipper iButton key"
+
+#define IBUTTON_KEY_NAME_SIZE 22
+
+typedef enum {
+    iButtonWriteModeInvalid,
+    iButtonWriteModeBlank,
+    iButtonWriteModeCopy,
+} iButtonWriteMode;
 
 struct iButton {
     SceneManager* scene_manager;
@@ -38,21 +47,22 @@ struct iButton {
     Storage* storage;
     DialogsApp* dialogs;
     NotificationApp* notifications;
+    RpcAppSystem* rpc;
 
-    iButtonWorker* key_worker;
     iButtonKey* key;
+    iButtonWorker* worker;
+    iButtonProtocols* protocols;
+    iButtonWriteMode write_mode;
 
     FuriString* file_path;
-    char text_store[IBUTTON_TEXT_STORE_SIZE + 1];
+    char key_name[IBUTTON_KEY_NAME_SIZE + 1];
 
     Submenu* submenu;
     ByteInput* byte_input;
     TextInput* text_input;
     Popup* popup;
     Widget* widget;
-    DialogEx* dialog_ex;
-
-    void* rpc_ctx;
+    Loading* loading;
 };
 
 typedef enum {
@@ -61,7 +71,7 @@ typedef enum {
     iButtonViewTextInput,
     iButtonViewPopup,
     iButtonViewWidget,
-    iButtonViewDialogEx,
+    iButtonViewLoading,
 } iButtonView;
 
 typedef enum {
@@ -78,10 +88,12 @@ typedef enum {
     iButtonNotificationMessageBlinkStop,
 } iButtonNotificationMessage;
 
-bool ibutton_file_select(iButton* ibutton);
-bool ibutton_load_key_data(iButton* ibutton, FuriString* key_path, bool show_dialog);
-bool ibutton_save_key(iButton* ibutton, const char* key_name);
+bool ibutton_select_and_load_key(iButton* ibutton);
+bool ibutton_load_key(iButton* ibutton);
+bool ibutton_save_key(iButton* ibutton);
 bool ibutton_delete_key(iButton* ibutton);
-void ibutton_text_store_set(iButton* ibutton, const char* text, ...);
-void ibutton_text_store_clear(iButton* ibutton);
+void ibutton_reset_key(iButton* ibutton);
 void ibutton_notification_message(iButton* ibutton, uint32_t message);
+
+void ibutton_submenu_callback(void* context, uint32_t index);
+void ibutton_widget_callback(GuiButtonType result, InputType type, void* context);
diff --git a/applications/main/ibutton/scenes/ibutton_scene_add_type.c b/applications/main/ibutton/scenes/ibutton_scene_add_type.c
index 38373999c9..55e05f20d7 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_add_type.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_add_type.c
@@ -1,54 +1,57 @@
 #include "../ibutton_i.h"
 
-enum SubmenuIndex {
-    SubmenuIndexCyfral,
-    SubmenuIndexDallas,
-    SubmenuIndexMetakom,
-};
-
-void ibutton_scene_add_type_submenu_callback(void* context, uint32_t index) {
-    iButton* ibutton = context;
-    view_dispatcher_send_custom_event(ibutton->view_dispatcher, index);
-}
-
 void ibutton_scene_add_type_on_enter(void* context) {
     iButton* ibutton = context;
     Submenu* submenu = ibutton->submenu;
 
-    submenu_add_item(
-        submenu, "Cyfral", SubmenuIndexCyfral, ibutton_scene_add_type_submenu_callback, ibutton);
-    submenu_add_item(
-        submenu, "Dallas", SubmenuIndexDallas, ibutton_scene_add_type_submenu_callback, ibutton);
-    submenu_add_item(
-        submenu, "Metakom", SubmenuIndexMetakom, ibutton_scene_add_type_submenu_callback, ibutton);
+    FuriString* tmp = furi_string_alloc();
+
+    for(uint32_t protocol_id = 0; protocol_id < ibutton_protocols_get_protocol_count();
+        ++protocol_id) {
+        if((strcmp(
+                ibutton_protocols_get_manufacturer(ibutton->protocols, protocol_id),
+                ibutton_protocols_get_name(ibutton->protocols, protocol_id)) != 0) &&
+           (strcmp(ibutton_protocols_get_manufacturer(ibutton->protocols, protocol_id), "N/A") !=
+            0)) {
+            furi_string_printf(
+                tmp,
+                "%s %s",
+                ibutton_protocols_get_manufacturer(ibutton->protocols, protocol_id),
+                ibutton_protocols_get_name(ibutton->protocols, protocol_id));
+        } else {
+            furi_string_printf(
+                tmp, "%s", ibutton_protocols_get_name(ibutton->protocols, protocol_id));
+        }
+
+        submenu_add_item(
+            submenu, furi_string_get_cstr(tmp), protocol_id, ibutton_submenu_callback, context);
+    }
 
-    submenu_set_selected_item(
-        submenu, scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneAddType));
+    const uint32_t prev_protocol_id =
+        scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneAddType);
+    submenu_set_selected_item(submenu, prev_protocol_id);
 
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewSubmenu);
+    furi_string_free(tmp);
 }
 
 bool ibutton_scene_add_type_on_event(void* context, SceneManagerEvent event) {
     iButton* ibutton = context;
     iButtonKey* key = ibutton->key;
+
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(ibutton->scene_manager, iButtonSceneAddType, event.event);
-        consumed = true;
-        if(event.event == SubmenuIndexCyfral) {
-            ibutton_key_set_type(key, iButtonKeyCyfral);
-        } else if(event.event == SubmenuIndexDallas) {
-            ibutton_key_set_type(key, iButtonKeyDS1990);
-        } else if(event.event == SubmenuIndexMetakom) {
-            ibutton_key_set_type(key, iButtonKeyMetakom);
-        } else {
-            furi_crash("Unknown key type");
-        }
+        const iButtonProtocolId protocol_id = event.event;
 
-        furi_string_set(ibutton->file_path, IBUTTON_APP_FOLDER);
-        ibutton_key_clear_data(key);
+        ibutton_key_reset(key);
+        ibutton_key_set_protocol_id(key, protocol_id);
+        ibutton_protocols_apply_edits(ibutton->protocols, key);
+
+        scene_manager_set_scene_state(ibutton->scene_manager, iButtonSceneAddType, protocol_id);
         scene_manager_next_scene(ibutton->scene_manager, iButtonSceneAddValue);
+
+        consumed = true;
     }
 
     return consumed;
diff --git a/applications/main/ibutton/scenes/ibutton_scene_add_value.c b/applications/main/ibutton/scenes/ibutton_scene_add_value.c
index ccac761210..dc340771b2 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_add_value.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_add_value.c
@@ -1,42 +1,52 @@
 #include "../ibutton_i.h"
 
-void ibutton_scene_add_type_byte_input_callback(void* context) {
+static void ibutton_scene_add_type_byte_input_callback(void* context) {
     iButton* ibutton = context;
     view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventByteEditResult);
 }
 
+static void ibutton_scene_add_type_byte_changed_callback(void* context) {
+    iButton* ibutton = context;
+    view_dispatcher_send_custom_event(ibutton->view_dispatcher, iButtonCustomEventByteEditChanged);
+}
+
 void ibutton_scene_add_value_on_enter(void* context) {
     iButton* ibutton = context;
-    iButtonKey* key = ibutton->key;
-    uint8_t* new_key_data = malloc(IBUTTON_KEY_DATA_SIZE);
+    byte_input_set_header_text(ibutton->byte_input, "Enter the key");
 
-    scene_manager_set_scene_state(
-        ibutton->scene_manager, iButtonSceneAddValue, (uint32_t)new_key_data);
-    memcpy(new_key_data, ibutton_key_get_data_p(key), ibutton_key_get_data_size(key));
+    iButtonEditableData editable_data;
+    ibutton_protocols_get_editable_data(ibutton->protocols, ibutton->key, &editable_data);
 
     byte_input_set_result_callback(
         ibutton->byte_input,
         ibutton_scene_add_type_byte_input_callback,
-        NULL,
-        ibutton,
-        new_key_data,
-        ibutton_key_get_data_size(key));
+        ibutton_scene_add_type_byte_changed_callback,
+        context,
+        editable_data.ptr,
+        editable_data.size);
 
-    byte_input_set_header_text(ibutton->byte_input, "Enter the key");
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewByteInput);
 }
 
 bool ibutton_scene_add_value_on_event(void* context, SceneManagerEvent event) {
     iButton* ibutton = context;
-    uint8_t* new_key_data =
-        (uint8_t*)scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneAddValue);
+    SceneManager* scene_manager = ibutton->scene_manager;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
         if(event.event == iButtonCustomEventByteEditResult) {
-            ibutton_key_set_data(ibutton->key, new_key_data, IBUTTON_KEY_DATA_SIZE);
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneSaveName);
+            scene_manager_next_scene(scene_manager, iButtonSceneSaveName);
+        } else if(event.event == iButtonCustomEventByteEditChanged) {
+            ibutton_protocols_apply_edits(ibutton->protocols, ibutton->key);
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        // User cancelled editing, reload the key from storage
+        if(scene_manager_has_previous_scene(scene_manager, iButtonSceneSavedKeyMenu)) {
+            if(!ibutton_load_key(ibutton)) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    scene_manager, iButtonSceneStart);
+            }
         }
     }
 
@@ -45,10 +55,7 @@ bool ibutton_scene_add_value_on_event(void* context, SceneManagerEvent event) {
 
 void ibutton_scene_add_value_on_exit(void* context) {
     iButton* ibutton = context;
-    uint8_t* new_key_data =
-        (uint8_t*)scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneAddValue);
 
     byte_input_set_result_callback(ibutton->byte_input, NULL, NULL, NULL, NULL, 0);
     byte_input_set_header_text(ibutton->byte_input, NULL);
-    free(new_key_data);
 }
diff --git a/applications/main/ibutton/scenes/ibutton_scene_config.h b/applications/main/ibutton/scenes/ibutton_scene_config.h
index 87fa1a036a..79f6791b3b 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_config.h
+++ b/applications/main/ibutton/scenes/ibutton_scene_config.h
@@ -6,8 +6,7 @@ ADD_SCENE(ibutton, info, Info)
 ADD_SCENE(ibutton, read, Read)
 ADD_SCENE(ibutton, read_key_menu, ReadKeyMenu)
 ADD_SCENE(ibutton, read_success, ReadSuccess)
-ADD_SCENE(ibutton, read_crc_error, ReadCRCError)
-ADD_SCENE(ibutton, read_not_key_error, ReadNotKeyError)
+ADD_SCENE(ibutton, read_error, ReadError)
 ADD_SCENE(ibutton, select_key, SelectKey)
 ADD_SCENE(ibutton, add_type, AddType)
 ADD_SCENE(ibutton, add_value, AddValue)
@@ -18,4 +17,5 @@ ADD_SCENE(ibutton, delete_confirm, DeleteConfirm)
 ADD_SCENE(ibutton, delete_success, DeleteSuccess)
 ADD_SCENE(ibutton, retry_confirm, RetryConfirm)
 ADD_SCENE(ibutton, exit_confirm, ExitConfirm)
+ADD_SCENE(ibutton, view_data, ViewData)
 ADD_SCENE(ibutton, rpc, Rpc)
diff --git a/applications/main/ibutton/scenes/ibutton_scene_delete_confirm.c b/applications/main/ibutton/scenes/ibutton_scene_delete_confirm.c
index 3d609e833f..587cb748cd 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_delete_confirm.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_delete_confirm.c
@@ -1,74 +1,29 @@
 #include "../ibutton_i.h"
 #include <toolbox/path.h>
 
-static void ibutton_scene_delete_confirm_widget_callback(
-    GuiButtonType result,
-    InputType type,
-    void* context) {
-    iButton* ibutton = context;
-    if(type == InputTypeShort) {
-        view_dispatcher_send_custom_event(ibutton->view_dispatcher, result);
-    }
-}
-
 void ibutton_scene_delete_confirm_on_enter(void* context) {
     iButton* ibutton = context;
-    Widget* widget = ibutton->widget;
     iButtonKey* key = ibutton->key;
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
+    Widget* widget = ibutton->widget;
 
-    FuriString* key_name;
-    key_name = furi_string_alloc();
-    path_extract_filename(ibutton->file_path, key_name, true);
+    FuriString* tmp = furi_string_alloc();
 
-    ibutton_text_store_set(ibutton, "\e#Delete %s?\e#", furi_string_get_cstr(key_name));
-    widget_add_text_box_element(
-        widget, 0, 0, 128, 27, AlignCenter, AlignCenter, ibutton->text_store, true);
+    widget_add_button_element(widget, GuiButtonTypeLeft, "Back", ibutton_widget_callback, context);
     widget_add_button_element(
-        widget, GuiButtonTypeLeft, "Cancel", ibutton_scene_delete_confirm_widget_callback, ibutton);
-    widget_add_button_element(
-        widget,
-        GuiButtonTypeRight,
-        "Delete",
-        ibutton_scene_delete_confirm_widget_callback,
-        ibutton);
+        widget, GuiButtonTypeRight, "Delete", ibutton_widget_callback, context);
 
-    switch(ibutton_key_get_type(key)) {
-    case iButtonKeyDS1990:
-        ibutton_text_store_set(
-            ibutton,
-            "%02X %02X %02X %02X %02X %02X %02X %02X",
-            key_data[0],
-            key_data[1],
-            key_data[2],
-            key_data[3],
-            key_data[4],
-            key_data[5],
-            key_data[6],
-            key_data[7]);
-        widget_add_string_element(
-            widget, 64, 34, AlignCenter, AlignBottom, FontSecondary, "Dallas");
-        break;
+    furi_string_printf(tmp, "Delete %s?", ibutton->key_name);
+    widget_add_string_element(
+        widget, 128 / 2, 0, AlignCenter, AlignTop, FontPrimary, furi_string_get_cstr(tmp));
 
-    case iButtonKeyCyfral:
-        ibutton_text_store_set(ibutton, "%02X %02X", key_data[0], key_data[1]);
-        widget_add_string_element(
-            widget, 64, 34, AlignCenter, AlignBottom, FontSecondary, "Cyfral");
-        break;
+    furi_string_reset(tmp);
+    ibutton_protocols_render_brief_data(ibutton->protocols, key, tmp);
 
-    case iButtonKeyMetakom:
-        ibutton_text_store_set(
-            ibutton, "%02X %02X %02X %02X", key_data[0], key_data[1], key_data[2], key_data[3]);
-        widget_add_string_element(
-            widget, 64, 34, AlignCenter, AlignBottom, FontSecondary, "Metakom");
-        break;
-    }
-    widget_add_string_element(
-        widget, 64, 46, AlignCenter, AlignBottom, FontSecondary, ibutton->text_store);
+    widget_add_string_multiline_element(
+        widget, 128 / 2, 16, AlignCenter, AlignTop, FontSecondary, furi_string_get_cstr(tmp));
 
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
-
-    furi_string_free(key_name);
+    furi_string_free(tmp);
 }
 
 bool ibutton_scene_delete_confirm_on_event(void* context, SceneManagerEvent event) {
@@ -81,8 +36,10 @@ bool ibutton_scene_delete_confirm_on_event(void* context, SceneManagerEvent even
         if(event.event == GuiButtonTypeRight) {
             if(ibutton_delete_key(ibutton)) {
                 scene_manager_next_scene(scene_manager, iButtonSceneDeleteSuccess);
+            } else {
+                dialog_message_show_storage_error(ibutton->dialogs, "Cannot delete\nkey file");
+                scene_manager_previous_scene(scene_manager);
             }
-            //TODO: What if the key could not be deleted?
         } else if(event.event == GuiButtonTypeLeft) {
             scene_manager_previous_scene(scene_manager);
         }
@@ -93,6 +50,5 @@ bool ibutton_scene_delete_confirm_on_event(void* context, SceneManagerEvent even
 
 void ibutton_scene_delete_confirm_on_exit(void* context) {
     iButton* ibutton = context;
-    ibutton_text_store_clear(ibutton);
     widget_reset(ibutton->widget);
 }
diff --git a/applications/main/ibutton/scenes/ibutton_scene_emulate.c b/applications/main/ibutton/scenes/ibutton_scene_emulate.c
index 6f6ffcf574..713b8331c3 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_emulate.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_emulate.c
@@ -14,61 +14,32 @@ static void ibutton_scene_emulate_callback(void* context, bool emulated) {
 
 void ibutton_scene_emulate_on_enter(void* context) {
     iButton* ibutton = context;
-    Widget* widget = ibutton->widget;
     iButtonKey* key = ibutton->key;
 
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
+    Widget* widget = ibutton->widget;
+    FuriString* tmp = furi_string_alloc();
 
-    FuriString* key_name;
-    key_name = furi_string_alloc();
-    if(furi_string_end_with(ibutton->file_path, IBUTTON_APP_EXTENSION)) {
-        path_extract_filename(ibutton->file_path, key_name, true);
-    }
+    widget_add_icon_element(widget, 3, 10, &I_iButtonKey_49x44);
 
-    // check that stored key has name
-    if(!furi_string_empty(key_name)) {
-        ibutton_text_store_set(ibutton, "%s", furi_string_get_cstr(key_name));
-    } else {
-        // if not, show key data
-        switch(ibutton_key_get_type(key)) {
-        case iButtonKeyDS1990:
-            ibutton_text_store_set(
-                ibutton,
-                "%02X %02X %02X %02X\n%02X %02X %02X %02X",
-                key_data[0],
-                key_data[1],
-                key_data[2],
-                key_data[3],
-                key_data[4],
-                key_data[5],
-                key_data[6],
-                key_data[7]);
-            break;
-        case iButtonKeyCyfral:
-            ibutton_text_store_set(ibutton, "%02X %02X", key_data[0], key_data[1]);
-            break;
-        case iButtonKeyMetakom:
-            ibutton_text_store_set(
-                ibutton, "%02X %02X %02X %02X", key_data[0], key_data[1], key_data[2], key_data[3]);
-            break;
-        }
-    }
+    furi_string_printf(
+        tmp,
+        "%s\n[%s]",
+        furi_string_empty(ibutton->file_path) ? "Unsaved Key" : ibutton->key_name,
+        ibutton_protocols_get_name(ibutton->protocols, ibutton_key_get_protocol_id(key)));
 
-    widget_add_string_multiline_element(
-        widget, 90, 10, AlignCenter, AlignTop, FontPrimary, "iButton\nemulating");
-    widget_add_icon_element(widget, 3, 10, &I_iButtonKey_49x44);
     widget_add_text_box_element(
-        widget, 54, 39, 75, 22, AlignCenter, AlignCenter, ibutton->text_store, true);
-
-    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
+        widget, 52, 38, 75, 26, AlignCenter, AlignCenter, furi_string_get_cstr(tmp), true);
 
-    ibutton_worker_emulate_set_callback(
-        ibutton->key_worker, ibutton_scene_emulate_callback, ibutton);
-    ibutton_worker_emulate_start(ibutton->key_worker, key);
+    widget_add_string_multiline_element(
+        widget, 88, 10, AlignCenter, AlignTop, FontPrimary, "iButton\nemulating");
 
-    furi_string_free(key_name);
+    ibutton_worker_emulate_set_callback(ibutton->worker, ibutton_scene_emulate_callback, ibutton);
+    ibutton_worker_emulate_start(ibutton->worker, key);
 
     ibutton_notification_message(ibutton, iButtonNotificationMessageEmulateStart);
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
+
+    furi_string_free(tmp);
 }
 
 bool ibutton_scene_emulate_on_event(void* context, SceneManagerEvent event) {
@@ -78,8 +49,7 @@ bool ibutton_scene_emulate_on_event(void* context, SceneManagerEvent event) {
     if(event.type == SceneManagerEventTypeTick) {
         uint32_t cnt = scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneEmulate);
         if(cnt > 0) {
-            cnt--;
-            if(cnt == 0) {
+            if(--cnt == 0) {
                 ibutton_notification_message(ibutton, iButtonNotificationMessageEmulateBlink);
             }
             scene_manager_set_scene_state(ibutton->scene_manager, iButtonSceneEmulate, cnt);
@@ -101,7 +71,7 @@ bool ibutton_scene_emulate_on_event(void* context, SceneManagerEvent event) {
 
 void ibutton_scene_emulate_on_exit(void* context) {
     iButton* ibutton = context;
-    ibutton_worker_stop(ibutton->key_worker);
+    ibutton_worker_stop(ibutton->worker);
     widget_reset(ibutton->widget);
     ibutton_notification_message(ibutton, iButtonNotificationMessageBlinkStop);
 }
diff --git a/applications/main/ibutton/scenes/ibutton_scene_exit_confirm.c b/applications/main/ibutton/scenes/ibutton_scene_exit_confirm.c
index 2367e12177..9029a4b7b0 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_exit_confirm.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_exit_confirm.c
@@ -19,7 +19,7 @@ void ibutton_scene_exit_confirm_on_enter(void* context) {
     widget_add_button_element(
         widget, GuiButtonTypeRight, "Stay", ibutton_scene_exit_confirm_widget_callback, ibutton);
     widget_add_string_element(
-        widget, 64, 19, AlignCenter, AlignBottom, FontPrimary, "Exit to iButton menu?");
+        widget, 64, 19, AlignCenter, AlignBottom, FontPrimary, "Exit to iButton Menu?");
     widget_add_string_element(
         widget, 64, 31, AlignCenter, AlignBottom, FontSecondary, "All unsaved data will be lost!");
 
diff --git a/applications/main/ibutton/scenes/ibutton_scene_info.c b/applications/main/ibutton/scenes/ibutton_scene_info.c
index 15648f6f29..cf44d6a865 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_info.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_info.c
@@ -1,66 +1,54 @@
 #include "../ibutton_i.h"
-#include <toolbox/path.h>
 
 void ibutton_scene_info_on_enter(void* context) {
     iButton* ibutton = context;
-    Widget* widget = ibutton->widget;
     iButtonKey* key = ibutton->key;
+    Widget* widget = ibutton->widget;
+
+    const iButtonProtocolId protocol_id = ibutton_key_get_protocol_id(key);
 
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
+    FuriString* tmp = furi_string_alloc();
 
-    FuriString* key_name;
-    key_name = furi_string_alloc();
-    path_extract_filename(ibutton->file_path, key_name, true);
+    furi_string_printf(
+        tmp,
+        "\e#%s [%s]\e#",
+        ibutton->key_name,
+        ibutton_protocols_get_name(ibutton->protocols, protocol_id));
 
-    ibutton_text_store_set(ibutton, "%s", furi_string_get_cstr(key_name));
     widget_add_text_box_element(
-        widget, 0, 0, 128, 23, AlignCenter, AlignCenter, ibutton->text_store, true);
+        widget, 0, 2, 128, 12, AlignLeft, AlignTop, furi_string_get_cstr(tmp), true);
 
-    switch(ibutton_key_get_type(key)) {
-    case iButtonKeyDS1990:
-        ibutton_text_store_set(
-            ibutton,
-            "%02X %02X %02X %02X %02X %02X %02X %02X",
-            key_data[0],
-            key_data[1],
-            key_data[2],
-            key_data[3],
-            key_data[4],
-            key_data[5],
-            key_data[6],
-            key_data[7]);
-        widget_add_string_element(widget, 64, 36, AlignCenter, AlignBottom, FontPrimary, "Dallas");
-        break;
+    furi_string_reset(tmp);
+    ibutton_protocols_render_brief_data(ibutton->protocols, key, tmp);
 
-    case iButtonKeyMetakom:
-        ibutton_text_store_set(
-            ibutton, "%02X %02X %02X %02X", key_data[0], key_data[1], key_data[2], key_data[3]);
-        widget_add_string_element(
-            widget, 64, 36, AlignCenter, AlignBottom, FontPrimary, "Metakom");
-        break;
+    widget_add_string_multiline_element(
+        widget, 0, 16, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(tmp));
 
-    case iButtonKeyCyfral:
-        ibutton_text_store_set(ibutton, "%02X %02X", key_data[0], key_data[1]);
-        widget_add_string_element(widget, 64, 36, AlignCenter, AlignBottom, FontPrimary, "Cyfral");
-        break;
+    if(ibutton_protocols_get_features(ibutton->protocols, protocol_id) &
+       iButtonProtocolFeatureExtData) {
+        widget_add_button_element(
+            widget, GuiButtonTypeRight, "More", ibutton_widget_callback, context);
     }
 
-    widget_add_string_element(
-        widget, 64, 50, AlignCenter, AlignBottom, FontSecondary, ibutton->text_store);
-
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
-
-    furi_string_free(key_name);
+    furi_string_free(tmp);
 }
 
 bool ibutton_scene_info_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
-    return false;
+    iButton* ibutton = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        consumed = true;
+        if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneViewData);
+        }
+    }
+
+    return consumed;
 }
 
 void ibutton_scene_info_on_exit(void* context) {
     iButton* ibutton = context;
-    ibutton_text_store_clear(ibutton);
     widget_reset(ibutton->widget);
 }
diff --git a/applications/main/ibutton/scenes/ibutton_scene_read.c b/applications/main/ibutton/scenes/ibutton_scene_read.c
index b5ee08e6f4..a840fb7b7e 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_read.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_read.c
@@ -10,14 +10,13 @@ void ibutton_scene_read_on_enter(void* context) {
     iButton* ibutton = context;
     Popup* popup = ibutton->popup;
     iButtonKey* key = ibutton->key;
-    iButtonWorker* worker = ibutton->key_worker;
+    iButtonWorker* worker = ibutton->worker;
 
     popup_set_header(popup, "iButton", 95, 26, AlignCenter, AlignBottom);
-    popup_set_text(popup, "Waiting\nfor key ...", 95, 30, AlignCenter, AlignTop);
+    popup_set_text(popup, "Apply key to\nFlipper's back", 95, 30, AlignCenter, AlignTop);
     popup_set_icon(popup, 0, 5, &I_DolphinWait_61x59);
 
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewPopup);
-    furi_string_set(ibutton->file_path, IBUTTON_APP_FOLDER);
 
     ibutton_worker_read_set_callback(worker, ibutton_scene_read_callback, ibutton);
     ibutton_worker_read_start(worker, key);
@@ -35,25 +34,14 @@ bool ibutton_scene_read_on_event(void* context, SceneManagerEvent event) {
     } else if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
         if(event.event == iButtonCustomEventWorkerRead) {
-            bool success = false;
-            iButtonKey* key = ibutton->key;
-
-            if(ibutton_key_get_type(key) == iButtonKeyDS1990) {
-                if(!ibutton_key_dallas_crc_is_valid(key)) {
-                    scene_manager_next_scene(scene_manager, iButtonSceneReadCRCError);
-                } else if(!ibutton_key_dallas_is_1990_key(key)) {
-                    scene_manager_next_scene(scene_manager, iButtonSceneReadNotKeyError);
-                } else {
-                    success = true;
-                }
-            } else {
-                success = true;
-            }
-
-            if(success) {
+            if(ibutton_protocols_is_valid(ibutton->protocols, ibutton->key)) {
                 ibutton_notification_message(ibutton, iButtonNotificationMessageSuccess);
                 scene_manager_next_scene(scene_manager, iButtonSceneReadSuccess);
+
                 DOLPHIN_DEED(DolphinDeedIbuttonReadSuccess);
+
+            } else {
+                scene_manager_next_scene(scene_manager, iButtonSceneReadError);
             }
         }
     }
@@ -64,7 +52,7 @@ bool ibutton_scene_read_on_event(void* context, SceneManagerEvent event) {
 void ibutton_scene_read_on_exit(void* context) {
     iButton* ibutton = context;
     Popup* popup = ibutton->popup;
-    ibutton_worker_stop(ibutton->key_worker);
+    ibutton_worker_stop(ibutton->worker);
     popup_set_header(popup, NULL, 0, 0, AlignCenter, AlignBottom);
     popup_set_text(popup, NULL, 0, 0, AlignCenter, AlignTop);
     popup_set_icon(popup, 0, 0, NULL);
diff --git a/applications/main/ibutton/scenes/ibutton_scene_read_crc_error.c b/applications/main/ibutton/scenes/ibutton_scene_read_crc_error.c
deleted file mode 100644
index f822ff6a28..0000000000
--- a/applications/main/ibutton/scenes/ibutton_scene_read_crc_error.c
+++ /dev/null
@@ -1,70 +0,0 @@
-#include "../ibutton_i.h"
-#include <one_wire/maxim_crc.h>
-
-static void ibutton_scene_read_crc_error_dialog_ex_callback(DialogExResult result, void* context) {
-    iButton* ibutton = context;
-    view_dispatcher_send_custom_event(ibutton->view_dispatcher, result);
-}
-
-void ibutton_scene_read_crc_error_on_enter(void* context) {
-    iButton* ibutton = context;
-    DialogEx* dialog_ex = ibutton->dialog_ex;
-    iButtonKey* key = ibutton->key;
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
-
-    ibutton_text_store_set(
-        ibutton,
-        "%02X %02X %02X %02X %02X %02X %02X %02X\nExpected CRC: %X",
-        key_data[0],
-        key_data[1],
-        key_data[2],
-        key_data[3],
-        key_data[4],
-        key_data[5],
-        key_data[6],
-        key_data[7],
-        maxim_crc8(key_data, 7, MAXIM_CRC8_INIT));
-
-    dialog_ex_set_header(dialog_ex, "CRC ERROR", 64, 10, AlignCenter, AlignCenter);
-    dialog_ex_set_text(dialog_ex, ibutton->text_store, 64, 19, AlignCenter, AlignTop);
-    dialog_ex_set_left_button_text(dialog_ex, "Retry");
-    dialog_ex_set_right_button_text(dialog_ex, "More");
-    dialog_ex_set_result_callback(dialog_ex, ibutton_scene_read_crc_error_dialog_ex_callback);
-    dialog_ex_set_context(dialog_ex, ibutton);
-
-    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewDialogEx);
-
-    ibutton_notification_message(ibutton, iButtonNotificationMessageError);
-    ibutton_notification_message(ibutton, iButtonNotificationMessageRedOn);
-}
-
-bool ibutton_scene_read_crc_error_on_event(void* context, SceneManagerEvent event) {
-    iButton* ibutton = context;
-    SceneManager* scene_manager = ibutton->scene_manager;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeBack) {
-        consumed = true;
-        scene_manager_next_scene(scene_manager, iButtonSceneExitConfirm);
-    } else if(event.type == SceneManagerEventTypeCustom) {
-        consumed = true;
-        if(event.event == DialogExResultRight) {
-            scene_manager_next_scene(scene_manager, iButtonSceneReadKeyMenu);
-        } else if(event.event == DialogExResultLeft) {
-            scene_manager_previous_scene(scene_manager);
-        }
-    }
-
-    return consumed;
-}
-
-void ibutton_scene_read_crc_error_on_exit(void* context) {
-    iButton* ibutton = context;
-    DialogEx* dialog_ex = ibutton->dialog_ex;
-
-    ibutton_text_store_clear(ibutton);
-
-    dialog_ex_reset(dialog_ex);
-
-    ibutton_notification_message(ibutton, iButtonNotificationMessageRedOff);
-}
diff --git a/applications/main/ibutton/scenes/ibutton_scene_read_error.c b/applications/main/ibutton/scenes/ibutton_scene_read_error.c
new file mode 100644
index 0000000000..e966384bfc
--- /dev/null
+++ b/applications/main/ibutton/scenes/ibutton_scene_read_error.c
@@ -0,0 +1,58 @@
+#include "../ibutton_i.h"
+#include <one_wire/maxim_crc.h>
+
+void ibutton_scene_read_error_on_enter(void* context) {
+    iButton* ibutton = context;
+    iButtonKey* key = ibutton->key;
+
+    Widget* widget = ibutton->widget;
+
+    FuriString* tmp = furi_string_alloc();
+
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Retry", ibutton_widget_callback, context);
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", ibutton_widget_callback, context);
+
+    widget_add_string_element(
+        widget, 128 / 2, 2, AlignCenter, AlignTop, FontPrimary, "Read Error");
+
+    ibutton_protocols_render_error(ibutton->protocols, key, tmp);
+
+    widget_add_string_multiline_element(
+        widget, 128 / 2, 16, AlignCenter, AlignTop, FontSecondary, furi_string_get_cstr(tmp));
+
+    ibutton_notification_message(ibutton, iButtonNotificationMessageError);
+    ibutton_notification_message(ibutton, iButtonNotificationMessageRedOn);
+
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
+    furi_string_free(tmp);
+}
+
+bool ibutton_scene_read_error_on_event(void* context, SceneManagerEvent event) {
+    iButton* ibutton = context;
+    SceneManager* scene_manager = ibutton->scene_manager;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeBack) {
+        consumed = true;
+        scene_manager_next_scene(scene_manager, iButtonSceneExitConfirm);
+
+    } else if(event.type == SceneManagerEventTypeCustom) {
+        consumed = true;
+        if(event.event == GuiButtonTypeLeft) {
+            scene_manager_previous_scene(scene_manager);
+        } else if(event.event == GuiButtonTypeRight) {
+            scene_manager_next_scene(scene_manager, iButtonSceneReadKeyMenu);
+        }
+    }
+
+    return consumed;
+}
+
+void ibutton_scene_read_error_on_exit(void* context) {
+    iButton* ibutton = context;
+
+    ibutton_notification_message(ibutton, iButtonNotificationMessageRedOff);
+    widget_reset(ibutton->widget);
+}
diff --git a/applications/main/ibutton/scenes/ibutton_scene_read_key_menu.c b/applications/main/ibutton/scenes/ibutton_scene_read_key_menu.c
index 0a8ecfa55f..716f72c7d3 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_read_key_menu.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_read_key_menu.c
@@ -4,7 +4,9 @@
 typedef enum {
     SubmenuIndexSave,
     SubmenuIndexEmulate,
-    SubmenuIndexWrite,
+    SubmenuIndexViewData,
+    SubmenuIndexWriteBlank,
+    SubmenuIndexWriteCopy,
 } SubmenuIndex;
 
 void ibutton_scene_read_key_menu_submenu_callback(void* context, uint32_t index) {
@@ -16,6 +18,9 @@ void ibutton_scene_read_key_menu_on_enter(void* context) {
     iButton* ibutton = context;
     Submenu* submenu = ibutton->submenu;
 
+    const iButtonProtocolId protocol_id = ibutton_key_get_protocol_id(ibutton->key);
+    const uint32_t features = ibutton_protocols_get_features(ibutton->protocols, protocol_id);
+
     submenu_add_item(
         submenu, "Save", SubmenuIndexSave, ibutton_scene_read_key_menu_submenu_callback, ibutton);
     submenu_add_item(
@@ -24,36 +29,66 @@ void ibutton_scene_read_key_menu_on_enter(void* context) {
         SubmenuIndexEmulate,
         ibutton_scene_read_key_menu_submenu_callback,
         ibutton);
-    if(ibutton_key_get_type(ibutton->key) == iButtonKeyDS1990) {
+
+    if(features & iButtonProtocolFeatureExtData) {
+        submenu_add_item(
+            submenu,
+            "View Data",
+            SubmenuIndexViewData,
+            ibutton_scene_read_key_menu_submenu_callback,
+            ibutton);
+    }
+
+    if(features & iButtonProtocolFeatureWriteBlank) {
         submenu_add_item(
             submenu,
-            "Write",
-            SubmenuIndexWrite,
+            "Write Blank",
+            SubmenuIndexWriteBlank,
             ibutton_scene_read_key_menu_submenu_callback,
             ibutton);
     }
+
+    if(features & iButtonProtocolFeatureWriteCopy) {
+        submenu_add_item(
+            submenu,
+            "Write Copy",
+            SubmenuIndexWriteCopy,
+            ibutton_scene_read_key_menu_submenu_callback,
+            ibutton);
+    }
+
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneReadKeyMenu));
-
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewSubmenu);
 }
 
 bool ibutton_scene_read_key_menu_on_event(void* context, SceneManagerEvent event) {
     iButton* ibutton = context;
+    SceneManager* scene_manager = ibutton->scene_manager;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(
-            ibutton->scene_manager, iButtonSceneReadKeyMenu, event.event);
+        scene_manager_set_scene_state(scene_manager, iButtonSceneReadKeyMenu, event.event);
         consumed = true;
+
         if(event.event == SubmenuIndexSave) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneSaveName);
+            scene_manager_next_scene(scene_manager, iButtonSceneSaveName);
         } else if(event.event == SubmenuIndexEmulate) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneEmulate);
+            scene_manager_next_scene(scene_manager, iButtonSceneEmulate);
             DOLPHIN_DEED(DolphinDeedIbuttonEmulate);
-        } else if(event.event == SubmenuIndexWrite) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneWrite);
+        } else if(event.event == SubmenuIndexViewData) {
+            scene_manager_next_scene(scene_manager, iButtonSceneViewData);
+        } else if(event.event == SubmenuIndexWriteBlank) {
+            ibutton->write_mode = iButtonWriteModeBlank;
+            scene_manager_next_scene(scene_manager, iButtonSceneWrite);
+        } else if(event.event == SubmenuIndexWriteCopy) {
+            ibutton->write_mode = iButtonWriteModeCopy;
+            scene_manager_next_scene(scene_manager, iButtonSceneWrite);
         }
+    } else if(event.event == SceneManagerEventTypeBack) {
+        scene_manager_set_scene_state(
+            ibutton->scene_manager, iButtonSceneReadKeyMenu, SubmenuIndexSave);
+        // Event is not consumed
     }
 
     return consumed;
diff --git a/applications/main/ibutton/scenes/ibutton_scene_read_not_key_error.c b/applications/main/ibutton/scenes/ibutton_scene_read_not_key_error.c
deleted file mode 100644
index 8a7528031c..0000000000
--- a/applications/main/ibutton/scenes/ibutton_scene_read_not_key_error.c
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "../ibutton_i.h"
-#include <one_wire/maxim_crc.h>
-
-static void
-    ibutton_scene_read_not_key_error_dialog_ex_callback(DialogExResult result, void* context) {
-    iButton* ibutton = context;
-    view_dispatcher_send_custom_event(ibutton->view_dispatcher, result);
-}
-
-void ibutton_scene_read_not_key_error_on_enter(void* context) {
-    iButton* ibutton = context;
-    DialogEx* dialog_ex = ibutton->dialog_ex;
-    iButtonKey* key = ibutton->key;
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
-
-    ibutton_text_store_set(
-        ibutton,
-        "THIS IS NOT A KEY\n%02X %02X %02X %02X %02X %02X %02X %02X",
-        key_data[0],
-        key_data[1],
-        key_data[2],
-        key_data[3],
-        key_data[4],
-        key_data[5],
-        key_data[6],
-        key_data[7],
-        maxim_crc8(key_data, 7, MAXIM_CRC8_INIT));
-
-    dialog_ex_set_header(dialog_ex, "CRC ERROR", 64, 10, AlignCenter, AlignCenter);
-    dialog_ex_set_text(dialog_ex, ibutton->text_store, 64, 19, AlignCenter, AlignTop);
-    dialog_ex_set_left_button_text(dialog_ex, "Retry");
-    dialog_ex_set_right_button_text(dialog_ex, "More");
-    dialog_ex_set_result_callback(dialog_ex, ibutton_scene_read_not_key_error_dialog_ex_callback);
-    dialog_ex_set_context(dialog_ex, ibutton);
-
-    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewDialogEx);
-
-    ibutton_notification_message(ibutton, iButtonNotificationMessageError);
-    ibutton_notification_message(ibutton, iButtonNotificationMessageRedOn);
-}
-
-bool ibutton_scene_read_not_key_error_on_event(void* context, SceneManagerEvent event) {
-    iButton* ibutton = context;
-    SceneManager* scene_manager = ibutton->scene_manager;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeBack) {
-        consumed = true;
-        scene_manager_next_scene(scene_manager, iButtonSceneExitConfirm);
-    } else if(event.type == SceneManagerEventTypeCustom) {
-        consumed = true;
-        if(event.event == DialogExResultRight) {
-            scene_manager_next_scene(scene_manager, iButtonSceneReadKeyMenu);
-        } else if(event.event == DialogExResultLeft) {
-            scene_manager_previous_scene(scene_manager);
-        }
-    }
-
-    return consumed;
-}
-
-void ibutton_scene_read_not_key_error_on_exit(void* context) {
-    iButton* ibutton = context;
-    DialogEx* dialog_ex = ibutton->dialog_ex;
-
-    ibutton_text_store_clear(ibutton);
-
-    dialog_ex_reset(dialog_ex);
-
-    ibutton_notification_message(ibutton, iButtonNotificationMessageRedOff);
-}
diff --git a/applications/main/ibutton/scenes/ibutton_scene_read_success.c b/applications/main/ibutton/scenes/ibutton_scene_read_success.c
index 749e7af37a..2e50bc9964 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_read_success.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_read_success.c
@@ -1,55 +1,40 @@
 #include "../ibutton_i.h"
-#include <dolphin/dolphin.h>
 
-static void ibutton_scene_read_success_dialog_ex_callback(DialogExResult result, void* context) {
-    iButton* ibutton = context;
-    view_dispatcher_send_custom_event(ibutton->view_dispatcher, result);
-}
+#include <dolphin/dolphin.h>
 
 void ibutton_scene_read_success_on_enter(void* context) {
     iButton* ibutton = context;
-    DialogEx* dialog_ex = ibutton->dialog_ex;
     iButtonKey* key = ibutton->key;
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
-
-    switch(ibutton_key_get_type(key)) {
-    case iButtonKeyDS1990:
-        ibutton_text_store_set(
-            ibutton,
-            "Dallas\n%02X %02X %02X %02X\n%02X %02X %02X %02X",
-            key_data[0],
-            key_data[1],
-            key_data[2],
-            key_data[3],
-            key_data[4],
-            key_data[5],
-            key_data[6],
-            key_data[7]);
-        break;
-    case iButtonKeyCyfral:
-        ibutton_text_store_set(ibutton, "Cyfral\n%02X %02X", key_data[0], key_data[1]);
-        break;
-    case iButtonKeyMetakom:
-        ibutton_text_store_set(
-            ibutton,
-            "Metakom\n%02X %02X %02X %02X",
-            key_data[0],
-            key_data[1],
-            key_data[2],
-            key_data[3]);
-        break;
-    }
+    Widget* widget = ibutton->widget;
+
+    FuriString* tmp = furi_string_alloc();
 
-    dialog_ex_set_text(dialog_ex, ibutton->text_store, 95, 30, AlignCenter, AlignCenter);
-    dialog_ex_set_left_button_text(dialog_ex, "Retry");
-    dialog_ex_set_right_button_text(dialog_ex, "More");
-    dialog_ex_set_icon(dialog_ex, 0, 1, &I_DolphinReadingSuccess_59x63);
-    dialog_ex_set_result_callback(dialog_ex, ibutton_scene_read_success_dialog_ex_callback);
-    dialog_ex_set_context(dialog_ex, ibutton);
+    const iButtonProtocolId protocol_id = ibutton_key_get_protocol_id(key);
 
-    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewDialogEx);
+    widget_add_button_element(
+        widget, GuiButtonTypeLeft, "Retry", ibutton_widget_callback, context);
+    widget_add_button_element(
+        widget, GuiButtonTypeRight, "More", ibutton_widget_callback, context);
 
+    furi_string_printf(
+        tmp,
+        "%s[%s]",
+        ibutton_protocols_get_name(ibutton->protocols, protocol_id),
+        ibutton_protocols_get_manufacturer(ibutton->protocols, protocol_id));
+
+    widget_add_string_element(
+        widget, 0, 2, AlignLeft, AlignTop, FontPrimary, furi_string_get_cstr(tmp));
+
+    furi_string_reset(tmp);
+    ibutton_protocols_render_brief_data(ibutton->protocols, key, tmp);
+
+    widget_add_string_multiline_element(
+        widget, 0, 16, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(tmp));
+
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
     ibutton_notification_message(ibutton, iButtonNotificationMessageGreenOn);
+
+    furi_string_free(tmp);
 }
 
 bool ibutton_scene_read_success_on_event(void* context, SceneManagerEvent event) {
@@ -62,9 +47,9 @@ bool ibutton_scene_read_success_on_event(void* context, SceneManagerEvent event)
         scene_manager_next_scene(scene_manager, iButtonSceneExitConfirm);
     } else if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
-        if(event.event == DialogExResultRight) {
+        if(event.event == GuiButtonTypeRight) {
             scene_manager_next_scene(scene_manager, iButtonSceneReadKeyMenu);
-        } else if(event.event == DialogExResultLeft) {
+        } else if(event.event == GuiButtonTypeLeft) {
             scene_manager_next_scene(scene_manager, iButtonSceneRetryConfirm);
         }
     }
@@ -74,11 +59,8 @@ bool ibutton_scene_read_success_on_event(void* context, SceneManagerEvent event)
 
 void ibutton_scene_read_success_on_exit(void* context) {
     iButton* ibutton = context;
-    DialogEx* dialog_ex = ibutton->dialog_ex;
-
-    ibutton_text_store_clear(ibutton);
 
-    dialog_ex_reset(dialog_ex);
+    widget_reset(ibutton->widget);
 
     ibutton_notification_message(ibutton, iButtonNotificationMessageGreenOff);
 }
diff --git a/applications/main/ibutton/scenes/ibutton_scene_retry_confirm.c b/applications/main/ibutton/scenes/ibutton_scene_retry_confirm.c
index 7f8c95b1e8..34de5b8778 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_retry_confirm.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_retry_confirm.c
@@ -19,7 +19,7 @@ void ibutton_scene_retry_confirm_on_enter(void* context) {
     widget_add_button_element(
         widget, GuiButtonTypeRight, "Stay", ibutton_scene_retry_confirm_widget_callback, ibutton);
     widget_add_string_element(
-        widget, 64, 19, AlignCenter, AlignBottom, FontPrimary, "Return to reading?");
+        widget, 64, 19, AlignCenter, AlignBottom, FontPrimary, "Retry Reading?");
     widget_add_string_element(
         widget, 64, 29, AlignCenter, AlignBottom, FontSecondary, "All unsaved data will be lost!");
 
diff --git a/applications/main/ibutton/scenes/ibutton_scene_rpc.c b/applications/main/ibutton/scenes/ibutton_scene_rpc.c
index b25b1b8dd8..9205eb4b46 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_rpc.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_rpc.c
@@ -1,6 +1,4 @@
 #include "../ibutton_i.h"
-#include <toolbox/path.h>
-#include <rpc/rpc_app.h>
 
 void ibutton_scene_rpc_on_enter(void* context) {
     iButton* ibutton = context;
@@ -17,8 +15,6 @@ void ibutton_scene_rpc_on_enter(void* context) {
 }
 
 bool ibutton_scene_rpc_on_event(void* context, SceneManagerEvent event) {
-    UNUSED(context);
-    UNUSED(event);
     iButton* ibutton = context;
     Popup* popup = ibutton->popup;
 
@@ -26,40 +22,32 @@ bool ibutton_scene_rpc_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
+
         if(event.event == iButtonCustomEventRpcLoad) {
-            const char* arg = rpc_system_app_get_data(ibutton->rpc_ctx);
             bool result = false;
-            if(arg && (furi_string_empty(ibutton->file_path))) {
-                furi_string_set(ibutton->file_path, arg);
-                if(ibutton_load_key_data(ibutton, ibutton->file_path, false)) {
-                    ibutton_worker_emulate_start(ibutton->key_worker, ibutton->key);
-                    FuriString* key_name;
-                    key_name = furi_string_alloc();
-                    if(furi_string_end_with(ibutton->file_path, IBUTTON_APP_EXTENSION)) {
-                        path_extract_filename(ibutton->file_path, key_name, true);
-                    }
-
-                    if(!furi_string_empty(key_name)) {
-                        ibutton_text_store_set(
-                            ibutton, "emulating\n%s", furi_string_get_cstr(key_name));
-                    } else {
-                        ibutton_text_store_set(ibutton, "emulating");
-                    }
-                    popup_set_text(popup, ibutton->text_store, 82, 32, AlignCenter, AlignTop);
+            const char* file_path = rpc_system_app_get_data(ibutton->rpc);
+
+            if(file_path && (furi_string_empty(ibutton->file_path))) {
+                furi_string_set(ibutton->file_path, file_path);
+
+                if(ibutton_load_key(ibutton)) {
+                    popup_set_text(popup, ibutton->key_name, 82, 32, AlignCenter, AlignTop);
+                    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewPopup);
 
                     ibutton_notification_message(ibutton, iButtonNotificationMessageEmulateStart);
+                    ibutton_worker_emulate_start(ibutton->worker, ibutton->key);
 
-                    furi_string_free(key_name);
                     result = true;
-                } else {
-                    furi_string_reset(ibutton->file_path);
                 }
             }
-            rpc_system_app_confirm(ibutton->rpc_ctx, RpcAppEventLoadFile, result);
+
+            rpc_system_app_confirm(ibutton->rpc, RpcAppEventLoadFile, result);
+
         } else if(event.event == iButtonCustomEventRpcExit) {
-            rpc_system_app_confirm(ibutton->rpc_ctx, RpcAppEventAppExit, true);
+            rpc_system_app_confirm(ibutton->rpc, RpcAppEventAppExit, true);
             scene_manager_stop(ibutton->scene_manager);
             view_dispatcher_stop(ibutton->view_dispatcher);
+
         } else if(event.event == iButtonCustomEventRpcSessionClose) {
             scene_manager_stop(ibutton->scene_manager);
             view_dispatcher_stop(ibutton->view_dispatcher);
diff --git a/applications/main/ibutton/scenes/ibutton_scene_save_name.c b/applications/main/ibutton/scenes/ibutton_scene_save_name.c
index 5f25a0002f..4ad0315e54 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_save_name.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_save_name.c
@@ -1,6 +1,8 @@
 #include "../ibutton_i.h"
-#include <lib/toolbox/random_name.h>
+
+#include <toolbox/random_name.h>
 #include <toolbox/path.h>
+
 #include <dolphin/dolphin.h>
 
 static void ibutton_scene_save_name_text_input_callback(void* context) {
@@ -12,17 +14,10 @@ void ibutton_scene_save_name_on_enter(void* context) {
     iButton* ibutton = context;
     TextInput* text_input = ibutton->text_input;
 
-    FuriString* key_name;
-    key_name = furi_string_alloc();
-    if(furi_string_end_with(ibutton->file_path, IBUTTON_APP_EXTENSION)) {
-        path_extract_filename(ibutton->file_path, key_name, true);
-    }
+    const bool is_new_file = furi_string_empty(ibutton->file_path);
 
-    const bool key_name_is_empty = furi_string_empty(key_name);
-    if(key_name_is_empty) {
-        set_random_name(ibutton->text_store, IBUTTON_TEXT_STORE_SIZE);
-    } else {
-        ibutton_text_store_set(ibutton, "%s", furi_string_get_cstr(key_name));
+    if(is_new_file) {
+        set_random_name(ibutton->key_name, IBUTTON_KEY_NAME_SIZE);
     }
 
     text_input_set_header_text(text_input, "Name the key");
@@ -30,23 +25,15 @@ void ibutton_scene_save_name_on_enter(void* context) {
         text_input,
         ibutton_scene_save_name_text_input_callback,
         ibutton,
-        ibutton->text_store,
+        ibutton->key_name,
         IBUTTON_KEY_NAME_SIZE,
-        key_name_is_empty);
-
-    FuriString* folder_path;
-    folder_path = furi_string_alloc();
+        is_new_file);
 
-    path_extract_dirname(furi_string_get_cstr(ibutton->file_path), folder_path);
-
-    ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
-        furi_string_get_cstr(folder_path), IBUTTON_APP_EXTENSION, furi_string_get_cstr(key_name));
+    ValidatorIsFile* validator_is_file =
+        validator_is_file_alloc_init(IBUTTON_APP_FOLDER, IBUTTON_APP_EXTENSION, ibutton->key_name);
     text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
 
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewTextInput);
-
-    furi_string_free(key_name);
-    furi_string_free(folder_path);
 }
 
 bool ibutton_scene_save_name_on_event(void* context, SceneManagerEvent event) {
@@ -56,8 +43,16 @@ bool ibutton_scene_save_name_on_event(void* context, SceneManagerEvent event) {
     if(event.type == SceneManagerEventTypeCustom) {
         consumed = true;
         if(event.event == iButtonCustomEventTextEditResult) {
-            if(ibutton_save_key(ibutton, ibutton->text_store)) {
+            furi_string_printf(
+                ibutton->file_path,
+                "%s/%s%s",
+                IBUTTON_APP_FOLDER,
+                ibutton->key_name,
+                IBUTTON_APP_EXTENSION);
+
+            if(ibutton_save_key(ibutton)) {
                 scene_manager_next_scene(ibutton->scene_manager, iButtonSceneSaveSuccess);
+
                 if(scene_manager_has_previous_scene(
                        ibutton->scene_manager, iButtonSceneSavedKeyMenu)) {
                     // Nothing, do not count editing as saving
@@ -67,6 +62,7 @@ bool ibutton_scene_save_name_on_event(void* context, SceneManagerEvent event) {
                 } else {
                     DOLPHIN_DEED(DolphinDeedIbuttonSave);
                 }
+
             } else {
                 const uint32_t possible_scenes[] = {
                     iButtonSceneReadKeyMenu, iButtonSceneSavedKeyMenu, iButtonSceneAddType};
diff --git a/applications/main/ibutton/scenes/ibutton_scene_saved_key_menu.c b/applications/main/ibutton/scenes/ibutton_scene_saved_key_menu.c
index e4c9c350ae..80fca28b5e 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_saved_key_menu.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_saved_key_menu.c
@@ -3,72 +3,70 @@
 
 enum SubmenuIndex {
     SubmenuIndexEmulate,
-    SubmenuIndexWrite,
+    SubmenuIndexWriteBlank,
+    SubmenuIndexWriteCopy,
     SubmenuIndexEdit,
     SubmenuIndexDelete,
     SubmenuIndexInfo,
 };
 
-void ibutton_scene_saved_key_menu_submenu_callback(void* context, uint32_t index) {
-    iButton* ibutton = context;
-    view_dispatcher_send_custom_event(ibutton->view_dispatcher, index);
-}
-
 void ibutton_scene_saved_key_menu_on_enter(void* context) {
     iButton* ibutton = context;
     Submenu* submenu = ibutton->submenu;
 
-    submenu_add_item(
-        submenu,
-        "Emulate",
-        SubmenuIndexEmulate,
-        ibutton_scene_saved_key_menu_submenu_callback,
-        ibutton);
-    if(ibutton_key_get_type(ibutton->key) == iButtonKeyDS1990) {
+    const uint32_t features = ibutton_protocols_get_features(
+        ibutton->protocols, ibutton_key_get_protocol_id(ibutton->key));
+
+    submenu_add_item(submenu, "Emulate", SubmenuIndexEmulate, ibutton_submenu_callback, ibutton);
+
+    if(features & iButtonProtocolFeatureWriteBlank) {
         submenu_add_item(
-            submenu,
-            "Write",
-            SubmenuIndexWrite,
-            ibutton_scene_saved_key_menu_submenu_callback,
-            ibutton);
+            submenu, "Write Blank", SubmenuIndexWriteBlank, ibutton_submenu_callback, ibutton);
     }
-    submenu_add_item(
-        submenu, "Edit", SubmenuIndexEdit, ibutton_scene_saved_key_menu_submenu_callback, ibutton);
-    submenu_add_item(
-        submenu,
-        "Delete",
-        SubmenuIndexDelete,
-        ibutton_scene_saved_key_menu_submenu_callback,
-        ibutton);
-    submenu_add_item(
-        submenu, "Info", SubmenuIndexInfo, ibutton_scene_saved_key_menu_submenu_callback, ibutton);
+
+    if(features & iButtonProtocolFeatureWriteCopy) {
+        submenu_add_item(
+            submenu, "Write Copy", SubmenuIndexWriteCopy, ibutton_submenu_callback, ibutton);
+    }
+
+    submenu_add_item(submenu, "Edit", SubmenuIndexEdit, ibutton_submenu_callback, ibutton);
+    submenu_add_item(submenu, "Delete", SubmenuIndexDelete, ibutton_submenu_callback, ibutton);
+    submenu_add_item(submenu, "Info", SubmenuIndexInfo, ibutton_submenu_callback, ibutton);
 
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneSavedKeyMenu));
-
     view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewSubmenu);
 }
 
 bool ibutton_scene_saved_key_menu_on_event(void* context, SceneManagerEvent event) {
     iButton* ibutton = context;
+    SceneManager* scene_manager = ibutton->scene_manager;
     bool consumed = false;
 
     if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(
-            ibutton->scene_manager, iButtonSceneSavedKeyMenu, event.event);
+        scene_manager_set_scene_state(scene_manager, iButtonSceneSavedKeyMenu, event.event);
         consumed = true;
         if(event.event == SubmenuIndexEmulate) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneEmulate);
+            scene_manager_next_scene(scene_manager, iButtonSceneEmulate);
             DOLPHIN_DEED(DolphinDeedIbuttonEmulate);
-        } else if(event.event == SubmenuIndexWrite) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneWrite);
+        } else if(event.event == SubmenuIndexWriteBlank) {
+            ibutton->write_mode = iButtonWriteModeBlank;
+            scene_manager_next_scene(scene_manager, iButtonSceneWrite);
+        } else if(event.event == SubmenuIndexWriteCopy) {
+            ibutton->write_mode = iButtonWriteModeCopy;
+            scene_manager_next_scene(scene_manager, iButtonSceneWrite);
         } else if(event.event == SubmenuIndexEdit) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneAddValue);
+            scene_manager_next_scene(scene_manager, iButtonSceneAddValue);
         } else if(event.event == SubmenuIndexDelete) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneDeleteConfirm);
+            scene_manager_next_scene(scene_manager, iButtonSceneDeleteConfirm);
         } else if(event.event == SubmenuIndexInfo) {
-            scene_manager_next_scene(ibutton->scene_manager, iButtonSceneInfo);
+            scene_manager_next_scene(scene_manager, iButtonSceneInfo);
         }
+
+    } else if(event.type == SceneManagerEventTypeBack) {
+        scene_manager_set_scene_state(
+            scene_manager, iButtonSceneSavedKeyMenu, SubmenuIndexEmulate);
+        // Event is not consumed
     }
 
     return consumed;
diff --git a/applications/main/ibutton/scenes/ibutton_scene_select_key.c b/applications/main/ibutton/scenes/ibutton_scene_select_key.c
index 32169a9c08..ebd504b1f1 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_select_key.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_select_key.c
@@ -3,11 +3,11 @@
 void ibutton_scene_select_key_on_enter(void* context) {
     iButton* ibutton = context;
 
-    if(!ibutton_file_select(ibutton)) {
+    if(ibutton_select_and_load_key(ibutton)) {
+        scene_manager_next_scene(ibutton->scene_manager, iButtonSceneSavedKeyMenu);
+    } else {
         scene_manager_search_and_switch_to_previous_scene(
             ibutton->scene_manager, iButtonSceneStart);
-    } else {
-        scene_manager_next_scene(ibutton->scene_manager, iButtonSceneSavedKeyMenu);
     }
 }
 
diff --git a/applications/main/ibutton/scenes/ibutton_scene_start.c b/applications/main/ibutton/scenes/ibutton_scene_start.c
index b8f6b07d6c..37bf96f39f 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_start.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_start.c
@@ -8,21 +8,15 @@ enum SubmenuIndex {
     SubmenuIndexAdd,
 };
 
-void ibutton_scene_start_submenu_callback(void* context, uint32_t index) {
-    iButton* ibutton = context;
-    view_dispatcher_send_custom_event(ibutton->view_dispatcher, index);
-}
-
 void ibutton_scene_start_on_enter(void* context) {
     iButton* ibutton = context;
     Submenu* submenu = ibutton->submenu;
 
-    submenu_add_item(
-        submenu, "Read", SubmenuIndexRead, ibutton_scene_start_submenu_callback, ibutton);
-    submenu_add_item(
-        submenu, "Saved", SubmenuIndexSaved, ibutton_scene_start_submenu_callback, ibutton);
-    submenu_add_item(
-        submenu, "Add Manually", SubmenuIndexAdd, ibutton_scene_start_submenu_callback, ibutton);
+    ibutton_reset_key(ibutton);
+
+    submenu_add_item(submenu, "Read", SubmenuIndexRead, ibutton_submenu_callback, ibutton);
+    submenu_add_item(submenu, "Saved", SubmenuIndexSaved, ibutton_submenu_callback, ibutton);
+    submenu_add_item(submenu, "Add Manually", SubmenuIndexAdd, ibutton_submenu_callback, ibutton);
 
     submenu_set_selected_item(
         submenu, scene_manager_get_scene_state(ibutton->scene_manager, iButtonSceneStart));
@@ -41,7 +35,6 @@ bool ibutton_scene_start_on_event(void* context, SceneManagerEvent event) {
             scene_manager_next_scene(ibutton->scene_manager, iButtonSceneRead);
             DOLPHIN_DEED(DolphinDeedIbuttonRead);
         } else if(event.event == SubmenuIndexSaved) {
-            furi_string_set(ibutton->file_path, IBUTTON_APP_FOLDER);
             scene_manager_next_scene(ibutton->scene_manager, iButtonSceneSelectKey);
         } else if(event.event == SubmenuIndexAdd) {
             scene_manager_next_scene(ibutton->scene_manager, iButtonSceneAddType);
diff --git a/applications/main/ibutton/scenes/ibutton_scene_view_data.c b/applications/main/ibutton/scenes/ibutton_scene_view_data.c
new file mode 100644
index 0000000000..7e063d7ec8
--- /dev/null
+++ b/applications/main/ibutton/scenes/ibutton_scene_view_data.c
@@ -0,0 +1,26 @@
+#include "../ibutton_i.h"
+
+void ibutton_scene_view_data_on_enter(void* context) {
+    iButton* ibutton = context;
+    iButtonKey* key = ibutton->key;
+    Widget* widget = ibutton->widget;
+
+    FuriString* tmp = furi_string_alloc();
+    ibutton_protocols_render_data(ibutton->protocols, key, tmp);
+
+    widget_add_text_scroll_element(widget, 0, 0, 128, 64, furi_string_get_cstr(tmp));
+
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
+    furi_string_free(tmp);
+}
+
+bool ibutton_scene_view_data_on_event(void* context, SceneManagerEvent event) {
+    UNUSED(context);
+    UNUSED(event);
+    return false;
+}
+
+void ibutton_scene_view_data_on_exit(void* context) {
+    iButton* ibutton = context;
+    widget_reset(ibutton->widget);
+}
diff --git a/applications/main/ibutton/scenes/ibutton_scene_write.c b/applications/main/ibutton/scenes/ibutton_scene_write.c
index cdea04db3d..541aa1c52b 100644
--- a/applications/main/ibutton/scenes/ibutton_scene_write.c
+++ b/applications/main/ibutton/scenes/ibutton_scene_write.c
@@ -1,5 +1,4 @@
 #include "../ibutton_i.h"
-#include "toolbox/path.h"
 
 typedef enum {
     iButtonSceneWriteStateDefault,
@@ -13,61 +12,46 @@ static void ibutton_scene_write_callback(void* context, iButtonWorkerWriteResult
 
 void ibutton_scene_write_on_enter(void* context) {
     iButton* ibutton = context;
+    furi_assert(ibutton->write_mode != iButtonWriteModeInvalid);
+
     iButtonKey* key = ibutton->key;
-    Widget* widget = ibutton->widget;
-    iButtonWorker* worker = ibutton->key_worker;
+    iButtonWorker* worker = ibutton->worker;
+    const iButtonProtocolId protocol_id = ibutton_key_get_protocol_id(key);
 
-    const uint8_t* key_data = ibutton_key_get_data_p(key);
+    Widget* widget = ibutton->widget;
+    FuriString* tmp = furi_string_alloc();
 
-    FuriString* key_name;
-    key_name = furi_string_alloc();
-    if(furi_string_end_with(ibutton->file_path, IBUTTON_APP_EXTENSION)) {
-        path_extract_filename(ibutton->file_path, key_name, true);
-    }
+    widget_add_icon_element(widget, 3, 10, &I_iButtonKey_49x44);
 
-    // check that stored key has name
-    if(!furi_string_empty(key_name)) {
-        ibutton_text_store_set(ibutton, "%s", furi_string_get_cstr(key_name));
-    } else {
-        // if not, show key data
-        switch(ibutton_key_get_type(key)) {
-        case iButtonKeyDS1990:
-            ibutton_text_store_set(
-                ibutton,
-                "%02X %02X %02X %02X\n%02X %02X %02X %02X",
-                key_data[0],
-                key_data[1],
-                key_data[2],
-                key_data[3],
-                key_data[4],
-                key_data[5],
-                key_data[6],
-                key_data[7]);
-            break;
-        case iButtonKeyCyfral:
-            ibutton_text_store_set(ibutton, "%02X %02X", key_data[0], key_data[1]);
-            break;
-        case iButtonKeyMetakom:
-            ibutton_text_store_set(
-                ibutton, "%02X %02X %02X %02X", key_data[0], key_data[1], key_data[2], key_data[3]);
-            break;
-        }
-    }
+    furi_string_printf(
+        tmp,
+        "%s\n[%s]",
+        ibutton->key_name,
+        ibutton_protocols_get_name(ibutton->protocols, protocol_id));
 
-    widget_add_string_multiline_element(
-        widget, 90, 10, AlignCenter, AlignTop, FontPrimary, "iButton\nwriting");
-    widget_add_icon_element(widget, 3, 10, &I_iButtonKey_49x44);
     widget_add_text_box_element(
-        widget, 54, 39, 75, 22, AlignCenter, AlignCenter, ibutton->text_store, true);
-
-    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
+        widget, 52, 38, 75, 26, AlignCenter, AlignCenter, furi_string_get_cstr(tmp), true);
 
     ibutton_worker_write_set_callback(worker, ibutton_scene_write_callback, ibutton);
-    ibutton_worker_write_start(worker, key);
 
-    furi_string_free(key_name);
+    furi_string_set(tmp, "iButton\nwriting ");
+
+    if(ibutton->write_mode == iButtonWriteModeBlank) {
+        furi_string_cat(tmp, "Blank");
+        ibutton_worker_write_blank_start(worker, key);
+
+    } else if(ibutton->write_mode == iButtonWriteModeCopy) {
+        furi_string_cat(tmp, "Copy");
+        ibutton_worker_write_copy_start(worker, key);
+    }
+
+    widget_add_string_multiline_element(
+        widget, 88, 10, AlignCenter, AlignTop, FontPrimary, furi_string_get_cstr(tmp));
 
     ibutton_notification_message(ibutton, iButtonNotificationMessageEmulateStart);
+    view_dispatcher_switch_to_view(ibutton->view_dispatcher, iButtonViewWidget);
+
+    furi_string_free(tmp);
 }
 
 bool ibutton_scene_write_on_event(void* context, SceneManagerEvent event) {
@@ -94,7 +78,9 @@ bool ibutton_scene_write_on_event(void* context, SceneManagerEvent event) {
 
 void ibutton_scene_write_on_exit(void* context) {
     iButton* ibutton = context;
-    ibutton_worker_stop(ibutton->key_worker);
+    ibutton->write_mode = iButtonWriteModeInvalid;
+
+    ibutton_worker_stop(ibutton->worker);
     widget_reset(ibutton->widget);
 
     ibutton_notification_message(ibutton, iButtonNotificationMessageBlinkStop);
diff --git a/applications/main/infrared/scenes/infrared_scene_ask_back.c b/applications/main/infrared/scenes/infrared_scene_ask_back.c
index 493458ade3..77fc97f987 100644
--- a/applications/main/infrared/scenes/infrared_scene_ask_back.c
+++ b/applications/main/infrared/scenes/infrared_scene_ask_back.c
@@ -10,13 +10,13 @@ void infrared_scene_ask_back_on_enter(void* context) {
     DialogEx* dialog_ex = infrared->dialog_ex;
 
     if(infrared->app_state.is_learning_new_remote) {
-        dialog_ex_set_header(dialog_ex, "Exit to Infrared Menu?", 64, 0, AlignCenter, AlignTop);
+        dialog_ex_set_header(dialog_ex, "Exit to Infrared Menu?", 64, 11, AlignCenter, AlignTop);
     } else {
-        dialog_ex_set_header(dialog_ex, "Exit to Remote Menu?", 64, 0, AlignCenter, AlignTop);
+        dialog_ex_set_header(dialog_ex, "Exit to Remote Menu?", 64, 11, AlignCenter, AlignTop);
     }
 
     dialog_ex_set_text(
-        dialog_ex, "All unsaved data\nwill be lost!", 64, 31, AlignCenter, AlignCenter);
+        dialog_ex, "All unsaved data\nwill be lost!", 64, 25, AlignCenter, AlignTop);
     dialog_ex_set_icon(dialog_ex, 0, 0, NULL);
     dialog_ex_set_left_button_text(dialog_ex, "Exit");
     dialog_ex_set_center_button_text(dialog_ex, NULL);
diff --git a/applications/main/infrared/scenes/infrared_scene_ask_retry.c b/applications/main/infrared/scenes/infrared_scene_ask_retry.c
index c87d9e6d3f..602e470c7c 100644
--- a/applications/main/infrared/scenes/infrared_scene_ask_retry.c
+++ b/applications/main/infrared/scenes/infrared_scene_ask_retry.c
@@ -9,9 +9,9 @@ void infrared_scene_ask_retry_on_enter(void* context) {
     Infrared* infrared = context;
     DialogEx* dialog_ex = infrared->dialog_ex;
 
-    dialog_ex_set_header(dialog_ex, "Return to Reading?", 64, 0, AlignCenter, AlignTop);
+    dialog_ex_set_header(dialog_ex, "Retry Reading?", 64, 11, AlignCenter, AlignTop);
     dialog_ex_set_text(
-        dialog_ex, "All unsaved data\nwill be lost!", 64, 31, AlignCenter, AlignCenter);
+        dialog_ex, "All unsaved data\nwill be lost!", 64, 25, AlignCenter, AlignTop);
     dialog_ex_set_icon(dialog_ex, 0, 0, NULL);
     dialog_ex_set_left_button_text(dialog_ex, "Exit");
     dialog_ex_set_center_button_text(dialog_ex, NULL);
diff --git a/applications/main/lfrfid/scenes/lfrfid_scene_retry_confirm.c b/applications/main/lfrfid/scenes/lfrfid_scene_retry_confirm.c
index f639f0ae1a..ddac3e8ba5 100644
--- a/applications/main/lfrfid/scenes/lfrfid_scene_retry_confirm.c
+++ b/applications/main/lfrfid/scenes/lfrfid_scene_retry_confirm.c
@@ -7,7 +7,7 @@ void lfrfid_scene_retry_confirm_on_enter(void* context) {
     widget_add_button_element(widget, GuiButtonTypeLeft, "Exit", lfrfid_widget_callback, app);
     widget_add_button_element(widget, GuiButtonTypeRight, "Stay", lfrfid_widget_callback, app);
     widget_add_string_element(
-        widget, 64, 19, AlignCenter, AlignBottom, FontPrimary, "Return to reading?");
+        widget, 64, 19, AlignCenter, AlignBottom, FontPrimary, "Retry Reading?");
     widget_add_string_element(
         widget, 64, 29, AlignCenter, AlignBottom, FontSecondary, "All unsaved data will be lost!");
 
diff --git a/applications/main/nfc/scenes/nfc_scene_mf_classic_menu.c b/applications/main/nfc/scenes/nfc_scene_mf_classic_menu.c
index 5fbdabe302..67b2a85309 100644
--- a/applications/main/nfc/scenes/nfc_scene_mf_classic_menu.c
+++ b/applications/main/nfc/scenes/nfc_scene_mf_classic_menu.c
@@ -25,7 +25,7 @@ void nfc_scene_mf_classic_menu_on_enter(void* context) {
     if(!mf_classic_is_card_read(&nfc->dev->dev_data.mf_classic_data)) {
         submenu_add_item(
             submenu,
-            "Detect reader",
+            "Detect Reader",
             SubmenuIndexDetectReader,
             nfc_scene_mf_classic_menu_submenu_callback,
             nfc);
diff --git a/applications/main/nfc/scenes/nfc_scene_retry_confirm.c b/applications/main/nfc/scenes/nfc_scene_retry_confirm.c
index 366582ea80..5f4f7985e7 100644
--- a/applications/main/nfc/scenes/nfc_scene_retry_confirm.c
+++ b/applications/main/nfc/scenes/nfc_scene_retry_confirm.c
@@ -14,7 +14,7 @@ void nfc_scene_retry_confirm_on_enter(void* context) {
     dialog_ex_set_right_button_text(dialog_ex, "Stay");
     dialog_ex_set_header(dialog_ex, "Retry Reading?", 64, 11, AlignCenter, AlignTop);
     dialog_ex_set_text(
-        dialog_ex, "All unsaved data will be\nlost!", 64, 25, AlignCenter, AlignTop);
+        dialog_ex, "All unsaved data\nwill be lost!", 64, 25, AlignCenter, AlignTop);
     dialog_ex_set_context(dialog_ex, nfc);
     dialog_ex_set_result_callback(dialog_ex, nfc_scene_retry_confirm_dialog_callback);
 
diff --git a/applications/main/nfc/scenes/nfc_scene_saved_menu.c b/applications/main/nfc/scenes/nfc_scene_saved_menu.c
index baef0a5ebc..e52493f2ae 100644
--- a/applications/main/nfc/scenes/nfc_scene_saved_menu.c
+++ b/applications/main/nfc/scenes/nfc_scene_saved_menu.c
@@ -52,20 +52,20 @@ void nfc_scene_saved_menu_on_enter(void* context) {
         if(!mf_classic_is_card_read(&nfc->dev->dev_data.mf_classic_data)) {
             submenu_add_item(
                 submenu,
-                "Detect reader",
+                "Detect Reader",
                 SubmenuIndexDetectReader,
                 nfc_scene_saved_menu_submenu_callback,
                 nfc);
         }
         submenu_add_item(
             submenu,
-            "Write To Initial Card",
+            "Write to Initial Card",
             SubmenuIndexWrite,
             nfc_scene_saved_menu_submenu_callback,
             nfc);
         submenu_add_item(
             submenu,
-            "Update From Initial Card",
+            "Update from Initial Card",
             SubmenuIndexUpdate,
             nfc_scene_saved_menu_submenu_callback,
             nfc);
@@ -76,13 +76,13 @@ void nfc_scene_saved_menu_on_enter(void* context) {
        !mf_ul_is_full_capture(&nfc->dev->dev_data.mf_ul_data)) {
         submenu_add_item(
             submenu,
-            "Unlock With Reader",
+            "Unlock with Reader",
             SubmenuIndexMfUlUnlockByReader,
             nfc_scene_saved_menu_submenu_callback,
             nfc);
         submenu_add_item(
             submenu,
-            "Unlock With Password",
+            "Unlock with Password",
             SubmenuIndexMfUlUnlockByPassword,
             nfc_scene_saved_menu_submenu_callback,
             nfc);
diff --git a/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c b/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
index d4e7197924..ab90547cb6 100644
--- a/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
+++ b/applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
@@ -119,9 +119,11 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
         for(size_t i = 0; i < subghz_setting_get_frequency_count(instance->setting); i++) {
             uint32_t current_frequency = subghz_setting_get_frequency(instance->setting, i);
             if(furi_hal_subghz_is_frequency_valid(current_frequency) &&
-               (current_frequency != 467750000) &&
+               (current_frequency != 467750000) && (current_frequency != 464000000) &&
                !((furi_hal_subghz.radio_type == SubGhzRadioExternal) &&
-                 (current_frequency >= 311900000 && current_frequency <= 312200000))) {
+                 ((current_frequency == 390000000) || (current_frequency == 312000000) ||
+                  (current_frequency == 312100000) || (current_frequency == 312200000) ||
+                  (current_frequency == 440175000)))) {
                 furi_hal_spi_acquire(furi_hal_subghz.spi_bus_handle);
                 cc1101_switch_to_idle(furi_hal_subghz.spi_bus_handle);
                 frequency =
diff --git a/applications/main/subghz/helpers/subghz_types.h b/applications/main/subghz/helpers/subghz_types.h
index 6e42c15235..3c59824276 100644
--- a/applications/main/subghz/helpers/subghz_types.h
+++ b/applications/main/subghz/helpers/subghz_types.h
@@ -54,6 +54,7 @@ typedef enum {
     SubGhzLoadKeyStateOK,
     SubGhzLoadKeyStateParseErr,
     SubGhzLoadKeyStateOnlyRx,
+    SubGhzLoadKeyStateProtocolDescriptionErr,
 } SubGhzLoadKeyState;
 
 /** SubGhzLock */
diff --git a/applications/main/subghz/scenes/subghz_scene_ext_module_settings.c b/applications/main/subghz/scenes/subghz_scene_ext_module_settings.c
index df81eae290..c586613329 100644
--- a/applications/main/subghz/scenes/subghz_scene_ext_module_settings.c
+++ b/applications/main/subghz/scenes/subghz_scene_ext_module_settings.c
@@ -4,6 +4,7 @@
 uint8_t value_index_exm;
 uint8_t value_index_dpin;
 uint8_t value_index_cnt;
+uint8_t value_index_pwr;
 
 #define EXT_MODULES_COUNT (sizeof(radio_modules_variables_text) / sizeof(char* const))
 const char* const radio_modules_variables_text[] = {
@@ -11,6 +12,12 @@ const char* const radio_modules_variables_text[] = {
     "External",
 };
 
+#define EXT_MOD_POWER_COUNT 2
+const char* const ext_mod_power_text[EXT_MOD_POWER_COUNT] = {
+    "ON",
+    "OFF",
+};
+
 #define DEBUG_P_COUNT 2
 const char* const debug_pin_text[DEBUG_P_COUNT] = {
     "OFF",
@@ -77,6 +84,19 @@ static void subghz_scene_receiver_config_set_debug_counter(VariableItem* item) {
     }
 }
 
+static void subghz_scene_receiver_config_set_ext_mod_power(VariableItem* item) {
+    uint8_t index = variable_item_get_current_value_index(item);
+
+    variable_item_set_current_value_text(item, ext_mod_power_text[index]);
+
+    furi_hal_subghz_set_external_power_disable(index == 1);
+    if(index == 1) {
+        furi_hal_subghz_disable_ext_power();
+    } else {
+        furi_hal_subghz_enable_ext_power();
+    }
+}
+
 void subghz_scene_ext_module_settings_on_enter(void* context) {
     SubGhz* subghz = context;
 
@@ -92,10 +112,20 @@ void subghz_scene_ext_module_settings_on_enter(void* context) {
     variable_item_set_current_value_index(item, value_index_exm);
     variable_item_set_current_value_text(item, radio_modules_variables_text[value_index_exm]);
 
+    item = variable_item_list_add(
+        subghz->variable_item_list,
+        "Ext Radio 5v",
+        EXT_MOD_POWER_COUNT,
+        subghz_scene_receiver_config_set_ext_mod_power,
+        subghz);
+    value_index_pwr = furi_hal_subghz_get_external_power_disable();
+    variable_item_set_current_value_index(item, value_index_pwr);
+    variable_item_set_current_value_text(item, ext_mod_power_text[value_index_pwr]);
+
     if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
         item = variable_item_list_add(
             subghz->variable_item_list,
-            "Debug Pin:",
+            "Debug Pin",
             DEBUG_P_COUNT,
             subghz_scene_receiver_config_set_debug_pin,
             subghz);
@@ -105,7 +135,7 @@ void subghz_scene_ext_module_settings_on_enter(void* context) {
 
         item = variable_item_list_add(
             subghz->variable_item_list,
-            "Counter Mult:",
+            "Counter incr.",
             DEBUG_COUNTER_COUNT,
             subghz_scene_receiver_config_set_debug_counter,
             subghz);
@@ -146,6 +176,8 @@ bool subghz_scene_ext_module_settings_on_event(void* context, SceneManagerEvent
     // Set selected radio module
     furi_hal_subghz_set_radio_type(value_index_exm);
 
+    furi_hal_subghz_enable_ext_power();
+
     // Check if module is present, if no -> show error
     if(!furi_hal_subghz_check_radio()) {
         value_index_exm = 0;
diff --git a/applications/main/subghz/scenes/subghz_scene_need_saving.c b/applications/main/subghz/scenes/subghz_scene_need_saving.c
index 2cfe060c76..5c6b9cc39e 100644
--- a/applications/main/subghz/scenes/subghz_scene_need_saving.c
+++ b/applications/main/subghz/scenes/subghz_scene_need_saving.c
@@ -16,7 +16,7 @@ void subghz_scene_need_saving_on_enter(void* context) {
     SubGhz* subghz = context;
 
     widget_add_string_multiline_element(
-        subghz->widget, 64, 13, AlignCenter, AlignCenter, FontPrimary, "Exit to Sub-GHz menu?");
+        subghz->widget, 64, 13, AlignCenter, AlignCenter, FontPrimary, "Exit to Sub-GHz Menu?");
     widget_add_string_multiline_element(
         subghz->widget,
         64,
@@ -24,7 +24,7 @@ void subghz_scene_need_saving_on_enter(void* context) {
         AlignCenter,
         AlignCenter,
         FontSecondary,
-        "All unsaved will be\nlost.");
+        "All unsaved data\nwill be lost!");
 
     widget_add_button_element(
         subghz->widget, GuiButtonTypeRight, "Stay", subghz_scene_need_saving_callback, subghz);
diff --git a/applications/main/subghz/scenes/subghz_scene_receiver_info.c b/applications/main/subghz/scenes/subghz_scene_receiver_info.c
index fd28421a81..90046eb9d1 100644
--- a/applications/main/subghz/scenes/subghz_scene_receiver_info.c
+++ b/applications/main/subghz/scenes/subghz_scene_receiver_info.c
@@ -27,8 +27,9 @@ static bool subghz_scene_receiver_info_update_parser(void* context) {
     subghz->txrx->decoder_result = subghz_receiver_search_decoder_base_by_name(
         subghz->txrx->receiver,
         subghz_history_get_protocol_name(subghz->txrx->history, subghz->txrx->idx_menu_chosen));
+
     if(subghz->txrx->decoder_result) {
-        // In this case flipper format was changed to short file content
+        //todo we are trying to deserialize without checking for errors, since it is assumed that we just received this chignal
         subghz_protocol_decoder_base_deserialize(
             subghz->txrx->decoder_result,
             subghz_history_get_raw_data(subghz->txrx->history, subghz->txrx->idx_menu_chosen));
@@ -138,7 +139,6 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
                        subghz,
                        subghz_history_get_raw_data(
                            subghz->txrx->history, subghz->txrx->idx_menu_chosen))) {
-                    scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
                     if(subghz->txrx->txrx_state == SubGhzTxRxStateTx) {
                         subghz_tx_stop(subghz);
                     }
diff --git a/applications/main/subghz/scenes/subghz_scene_set_type.c b/applications/main/subghz/scenes/subghz_scene_set_type.c
index 5c5d5db3bd..bc76ee146e 100644
--- a/applications/main/subghz/scenes/subghz_scene_set_type.c
+++ b/applications/main/subghz/scenes/subghz_scene_set_type.c
@@ -36,8 +36,9 @@ bool subghz_scene_set_type_submenu_gen_data_protocol(
     do {
         Stream* fff_data_stream = flipper_format_get_raw_stream(subghz->txrx->fff_data);
         stream_clean(fff_data_stream);
-        if(!subghz_protocol_decoder_base_serialize(
-               subghz->txrx->decoder_result, subghz->txrx->fff_data, subghz->txrx->preset)) {
+        if(subghz_protocol_decoder_base_serialize(
+               subghz->txrx->decoder_result, subghz->txrx->fff_data, subghz->txrx->preset) !=
+           SubGhzProtocolStatusOk) {
             FURI_LOG_E(TAG, "Unable to serialize");
             break;
         }
@@ -363,8 +364,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
         case SubmenuIndexSomfyTelis:
             subghz->txrx->transmitter = subghz_transmitter_alloc_init(
                 subghz->txrx->environment, SUBGHZ_PROTOCOL_SOMFY_TELIS_NAME);
-            subghz_preset_init(
-                subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            subghz_preset_init(subghz, "AM650", 433920000, NULL, 0);
             if(subghz->txrx->transmitter) {
                 subghz_protocol_somfy_telis_create_data(
                     subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
@@ -387,8 +387,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
         case SubmenuIndexDoorHan_433_92:
             subghz->txrx->transmitter = subghz_transmitter_alloc_init(
                 subghz->txrx->environment, SUBGHZ_PROTOCOL_KEELOQ_NAME);
-            subghz_preset_init(
-                subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            subghz_preset_init(subghz, "AM650", 433920000, NULL, 0);
             if(subghz->txrx->transmitter) {
                 subghz_protocol_keeloq_create_data(
                     subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
@@ -436,8 +435,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
         case SubmenuIndexNiceFlorS_433_92:
             subghz->txrx->transmitter = subghz_transmitter_alloc_init(
                 subghz->txrx->environment, SUBGHZ_PROTOCOL_NICE_FLOR_S_NAME);
-            subghz_preset_init(
-                subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            subghz_preset_init(subghz, "AM650", 433920000, NULL, 0);
             if(subghz->txrx->transmitter) {
                 subghz_protocol_nice_flor_s_create_data(
                     subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
@@ -461,8 +459,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
         case SubmenuIndexNiceOne_433_92:
             subghz->txrx->transmitter = subghz_transmitter_alloc_init(
                 subghz->txrx->environment, SUBGHZ_PROTOCOL_NICE_FLOR_S_NAME);
-            subghz_preset_init(
-                subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            subghz_preset_init(subghz, "AM650", 433920000, NULL, 0);
             if(subghz->txrx->transmitter) {
                 subghz_protocol_nice_flor_s_create_data(
                     subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
@@ -486,8 +483,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
         case SubmenuIndexNiceSmilo_433_92:
             subghz->txrx->transmitter = subghz_transmitter_alloc_init(
                 subghz->txrx->environment, SUBGHZ_PROTOCOL_KEELOQ_NAME);
-            subghz_preset_init(
-                subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+            subghz_preset_init(subghz, "AM650", 433920000, NULL, 0);
             if(subghz->txrx->transmitter) {
                 subghz_protocol_keeloq_create_data(
                     subghz_transmitter_get_protocol_instance(subghz->txrx->transmitter),
diff --git a/applications/main/subghz/scenes/subghz_scene_start.c b/applications/main/subghz/scenes/subghz_scene_start.c
index 69e6cbea7a..fd31353e0b 100644
--- a/applications/main/subghz/scenes/subghz_scene_start.c
+++ b/applications/main/subghz/scenes/subghz_scene_start.c
@@ -75,43 +75,46 @@ bool subghz_scene_start_on_event(void* context, SceneManagerEvent event) {
                 subghz->scene_manager, SubGhzSceneStart, SubmenuIndexExtSettings);
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneExtModuleSettings);
             return true;
-
-        } else if(!furi_hal_subghz_check_radio()) {
-            furi_string_set(subghz->error_str, "Please connect\nexternal radio");
-            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
-            return true;
-        } else if(event.event == SubmenuIndexReadRAW) {
-            scene_manager_set_scene_state(
-                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexReadRAW);
-            subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
-            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReadRAW);
-            return true;
-        } else if(event.event == SubmenuIndexRead) {
-            scene_manager_set_scene_state(
-                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexRead);
-            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiver);
-            return true;
-        } else if(event.event == SubmenuIndexSaved) {
-            scene_manager_set_scene_state(
-                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexSaved);
-            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaved);
-            return true;
         } else if(event.event == SubmenuIndexAddManually) {
             scene_manager_set_scene_state(
                 subghz->scene_manager, SubGhzSceneStart, SubmenuIndexAddManually);
             scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSetType);
             return true;
-        } else if(event.event == SubmenuIndexFrequencyAnalyzer) {
-            scene_manager_set_scene_state(
-                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexFrequencyAnalyzer);
-            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneFrequencyAnalyzer);
-            DOLPHIN_DEED(DolphinDeedSubGhzFrequencyAnalyzer);
-            return true;
-        } else if(event.event == SubmenuIndexTest) {
-            scene_manager_set_scene_state(
-                subghz->scene_manager, SubGhzSceneStart, SubmenuIndexTest);
-            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTest);
-            return true;
+        } else {
+            furi_hal_subghz_enable_ext_power();
+
+            if(!furi_hal_subghz_check_radio()) {
+                furi_string_set(subghz->error_str, "Please connect\nexternal radio");
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
+                return true;
+            } else if(event.event == SubmenuIndexReadRAW) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneStart, SubmenuIndexReadRAW);
+                subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReadRAW);
+                return true;
+            } else if(event.event == SubmenuIndexRead) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneStart, SubmenuIndexRead);
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneReceiver);
+                return true;
+            } else if(event.event == SubmenuIndexSaved) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneStart, SubmenuIndexSaved);
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaved);
+                return true;
+            } else if(event.event == SubmenuIndexFrequencyAnalyzer) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneStart, SubmenuIndexFrequencyAnalyzer);
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneFrequencyAnalyzer);
+                DOLPHIN_DEED(DolphinDeedSubGhzFrequencyAnalyzer);
+                return true;
+            } else if(event.event == SubmenuIndexTest) {
+                scene_manager_set_scene_state(
+                    subghz->scene_manager, SubGhzSceneStart, SubmenuIndexTest);
+                scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTest);
+                return true;
+            }
         }
     }
     return false;
diff --git a/applications/main/subghz/scenes/subghz_scene_transmitter.c b/applications/main/subghz/scenes/subghz_scene_transmitter.c
index 00839170c7..34685a8e57 100644
--- a/applications/main/subghz/scenes/subghz_scene_transmitter.c
+++ b/applications/main/subghz/scenes/subghz_scene_transmitter.c
@@ -14,9 +14,8 @@ void subghz_scene_transmitter_callback(SubGhzCustomEvent event, void* context) {
 }
 
 bool subghz_scene_transmitter_update_data_show(void* context) {
-    //ToDo Fix
     SubGhz* subghz = context;
-
+    bool ret = false;
     if(subghz->txrx->decoder_result) {
         FuriString* key_str;
         FuriString* frequency_str;
@@ -27,30 +26,29 @@ bool subghz_scene_transmitter_update_data_show(void* context) {
         modulation_str = furi_string_alloc();
         uint8_t show_button = 0;
 
-        subghz_protocol_decoder_base_deserialize(
-            subghz->txrx->decoder_result, subghz->txrx->fff_data);
-        subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, key_str);
-
-        if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Send) ==
-           SubGhzProtocolFlag_Send) {
-            show_button = 1;
-        }
+        if(subghz_protocol_decoder_base_deserialize(
+               subghz->txrx->decoder_result, subghz->txrx->fff_data) == SubGhzProtocolStatusOk) {
+            subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, key_str);
 
-        subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
-        subghz_view_transmitter_add_data_to_show(
-            subghz->subghz_transmitter,
-            furi_string_get_cstr(key_str),
-            furi_string_get_cstr(frequency_str),
-            furi_string_get_cstr(modulation_str),
-            show_button);
+            if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Send) ==
+               SubGhzProtocolFlag_Send) {
+                show_button = 1;
+            }
 
+            subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
+            subghz_view_transmitter_add_data_to_show(
+                subghz->subghz_transmitter,
+                furi_string_get_cstr(key_str),
+                furi_string_get_cstr(frequency_str),
+                furi_string_get_cstr(modulation_str),
+                show_button);
+            ret = true;
+        }
         furi_string_free(frequency_str);
         furi_string_free(modulation_str);
         furi_string_free(key_str);
-
-        return true;
     }
-    return false;
+    return ret;
 }
 
 void subghz_scene_transmitter_on_enter(void* context) {
diff --git a/applications/main/subghz/subghz.c b/applications/main/subghz/subghz.c
index ac92701141..e2b4841203 100644
--- a/applications/main/subghz/subghz.c
+++ b/applications/main/subghz/subghz.c
@@ -421,6 +421,9 @@ void subghz_free(SubGhz* subghz, bool alloc_for_tx_only) {
 
     // The rest
     free(subghz);
+
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
 }
 
 int32_t subghz_app(void* p) {
diff --git a/applications/main/subghz/subghz_i.c b/applications/main/subghz/subghz_i.c
index c1a1a92aeb..579a165205 100644
--- a/applications/main/subghz/subghz_i.c
+++ b/applications/main/subghz/subghz_i.c
@@ -154,7 +154,6 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
             FURI_LOG_E(TAG, "Missing Protocol");
             break;
         }
-        //ToDo FIX
         if(!flipper_format_insert_or_update_uint32(flipper_format, "Repeat", &repeat, 1)) {
             FURI_LOG_E(TAG, "Unable Repeat");
             break;
@@ -164,7 +163,8 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
             subghz->txrx->environment, furi_string_get_cstr(temp_str));
 
         if(subghz->txrx->transmitter) {
-            if(subghz_transmitter_deserialize(subghz->txrx->transmitter, flipper_format)) {
+            if(subghz_transmitter_deserialize(subghz->txrx->transmitter, flipper_format) ==
+               SubGhzProtocolStatusOk) {
                 if(strcmp(furi_string_get_cstr(subghz->txrx->preset->name), "") != 0) {
                     subghz_begin(
                         subghz,
@@ -187,7 +187,12 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
                     //Start TX
                     furi_hal_subghz_start_async_tx(
                         subghz_transmitter_yield, subghz->txrx->transmitter);
+                } else {
+                    subghz_dialog_message_show_only_rx(subghz);
                 }
+            } else {
+                dialog_message_show_storage_error(
+                    subghz->dialogs, "Error in protocol\nparameters\ndescription");
             }
         }
         if(!ret) {
@@ -335,8 +340,10 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
         subghz->txrx->decoder_result = subghz_receiver_search_decoder_base_by_name(
             subghz->txrx->receiver, furi_string_get_cstr(temp_str));
         if(subghz->txrx->decoder_result) {
-            if(!subghz_protocol_decoder_base_deserialize(
-                   subghz->txrx->decoder_result, subghz->txrx->fff_data)) {
+            SubGhzProtocolStatus status = subghz_protocol_decoder_base_deserialize(
+                subghz->txrx->decoder_result, subghz->txrx->fff_data);
+            if(status != SubGhzProtocolStatusOk) {
+                load_key_state = SubGhzLoadKeyStateProtocolDescriptionErr;
                 break;
             }
         } else {
@@ -357,6 +364,12 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
             dialog_message_show_storage_error(subghz->dialogs, "Cannot parse\nfile");
         }
         return false;
+    case SubGhzLoadKeyStateProtocolDescriptionErr:
+        if(show_dialog) {
+            dialog_message_show_storage_error(
+                subghz->dialogs, "Error in protocol\nparameters\ndescription");
+        }
+        return false;
 
     case SubGhzLoadKeyStateOnlyRx:
         if(show_dialog) {
diff --git a/applications/main/unirfremix/application.fam b/applications/main/subghz_remote/application.fam
similarity index 55%
rename from applications/main/unirfremix/application.fam
rename to applications/main/subghz_remote/application.fam
index fd35539472..e09f8500ff 100644
--- a/applications/main/unirfremix/application.fam
+++ b/applications/main/subghz_remote/application.fam
@@ -1,14 +1,14 @@
 App(
-    appid="unirfremix",
+    appid="subghz_remote",
     name="Sub-GHz Remote",
     apptype=FlipperAppType.APP,
-    entry_point="unirfremix_app",
-    cdefines=["APP_UNIRFREMIX"],
+    entry_point="subghz_remote_app",
+    cdefines=["APP_SUBGHZREMOTE"],
     requires=[
         "gui",
         "dialogs",
     ],
-    icon="A_UniRFRemix_14",
+    icon="A_SubGHzRemote_14",
     stack_size=4 * 1024,
     order=11,
 )
diff --git a/applications/main/unirfremix/unirfremix_app.c b/applications/main/subghz_remote/subghz_remote_app.c
similarity index 89%
rename from applications/main/unirfremix/unirfremix_app.c
rename to applications/main/subghz_remote/subghz_remote_app.c
index 597870f940..b64c87002a 100644
--- a/applications/main/unirfremix/unirfremix_app.c
+++ b/applications/main/subghz_remote/subghz_remote_app.c
@@ -23,10 +23,10 @@
 #include <lib/subghz/protocols/nice_flor_s.h>
 #include <lib/subghz/protocols/somfy_telis.h>
 
-#define UNIRFMAP_FOLDER "/ext/unirf"
-#define UNIRFMAP_EXTENSION ".txt"
+#define SUBREMOTEMAP_FOLDER "/ext/subghz_remote"
+#define SUBREMOTEMAP_EXTENSION ".txt"
 
-#define TAG "UniRF Remix"
+#define TAG "SubGHzRemote"
 
 typedef struct {
     uint32_t frequency;
@@ -39,7 +39,7 @@ typedef struct {
     size_t data_size;
 
     SubGhzProtocolDecoderBase* decoder;
-} UniRFPreset;
+} SubRemotePreset;
 
 typedef struct {
     FuriMutex* model_mutex;
@@ -53,7 +53,7 @@ typedef struct {
     SubGhzEnvironment* environment;
     SubGhzReceiver* subghz_receiver;
     NotificationApp* notification;
-    UniRFPreset* txpreset;
+    SubRemotePreset* txpreset;
 
     FuriString* up_file;
     FuriString* down_file;
@@ -88,17 +88,17 @@ typedef struct {
     bool tx_not_allowed;
 
     FuriString* signal;
-} UniRFRemix;
+} SubGHzRemote;
 
-UniRFPreset* unirfremix_preset_alloc(void) {
-    UniRFPreset* preset = malloc(sizeof(UniRFPreset));
+SubRemotePreset* subghz_remote_preset_alloc(void) {
+    SubRemotePreset* preset = malloc(sizeof(SubRemotePreset));
     preset->name = furi_string_alloc();
     preset->protocol = furi_string_alloc();
     preset->repeat = 200;
     return preset;
 }
 
-void unirfremix_preset_free(UniRFPreset* preset) {
+void subghz_remote_preset_free(SubRemotePreset* preset) {
     furi_string_free(preset->name);
     furi_string_free(preset->protocol);
     free(preset);
@@ -170,7 +170,7 @@ static void cfg_read_file_label(
  * set error flag if missing map file
  */
 
-void unirfremix_cfg_set_check(UniRFRemix* app, FuriString* file_name) {
+void subghz_remote_cfg_set_check(SubGHzRemote* app, FuriString* file_name) {
     Storage* storage = furi_record_open(RECORD_STORAGE);
     FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
 
@@ -313,11 +313,11 @@ void unirfremix_cfg_set_check(UniRFRemix* app, FuriString* file_name) {
     }
 }
 
-static void unirfremix_end_send(UniRFRemix* app) {
+static void subghz_remote_end_send(SubGHzRemote* app) {
     app->processing = 0;
 }
 
-bool unirfremix_set_preset(UniRFPreset* p, const char* preset) {
+bool subghz_remote_set_preset(SubRemotePreset* p, const char* preset) {
     if(!strcmp(preset, "FuriHalSubGhzPresetOok270Async")) {
         furi_string_set(p->name, "AM270");
     } else if(!strcmp(preset, "FuriHalSubGhzPresetOok650Async")) {
@@ -337,8 +337,8 @@ bool unirfremix_set_preset(UniRFPreset* p, const char* preset) {
     return true;
 }
 
-bool unirfremix_key_load(
-    UniRFPreset* preset,
+bool subghz_remote_key_load(
+    SubRemotePreset* preset,
     FlipperFormat* fff_file,
     FlipperFormat* fff_data,
     SubGhzSetting* setting,
@@ -367,7 +367,7 @@ bool unirfremix_key_load(
             FURI_LOG_W(TAG, "Could not read Preset. Defaulting to Ook650Async");
             furi_string_set(temp_str, "FuriHalSubGhzPresetOok650Async");
         }
-        if(!unirfremix_set_preset(preset, furi_string_get_cstr(temp_str))) {
+        if(!subghz_remote_set_preset(preset, furi_string_get_cstr(temp_str))) {
             FURI_LOG_E(TAG, "Could not set preset");
             break;
         }
@@ -402,7 +402,10 @@ bool unirfremix_key_load(
         preset->decoder = subghz_receiver_search_decoder_base_by_name(
             receiver, furi_string_get_cstr(preset->protocol));
         if(preset->decoder) {
-            if(!subghz_protocol_decoder_base_deserialize(preset->decoder, fff_data)) {
+            SubGhzProtocolStatus status =
+                subghz_protocol_decoder_base_deserialize(preset->decoder, fff_data);
+            if(status != SubGhzProtocolStatusOk) {
+                FURI_LOG_E(TAG, "Protocol deserialize failed, status = %d", status);
                 break;
             }
         } else {
@@ -419,7 +422,7 @@ bool unirfremix_key_load(
 
 // method modified from subghz_i.c
 // https://github.com/flipperdevices/flipperzero-firmware/blob/b0daa601ad5b87427a45f9089c8b403a01f72c2a/applications/subghz/subghz_i.c#L417-L456
-bool unirfremix_save_protocol_to_file(FlipperFormat* fff_file, const char* dev_file_name) {
+bool subghz_remote_save_protocol_to_file(FlipperFormat* fff_file, const char* dev_file_name) {
     furi_assert(fff_file);
     furi_assert(dev_file_name);
 
@@ -456,7 +459,7 @@ bool unirfremix_save_protocol_to_file(FlipperFormat* fff_file, const char* dev_f
     return saved;
 }
 
-void unirfremix_tx_stop(UniRFRemix* app) {
+void subghz_remote_tx_stop(SubGHzRemote* app) {
     if(app->processing == 0) {
         return;
     }
@@ -480,7 +483,7 @@ void unirfremix_tx_stop(UniRFRemix* app) {
     FURI_LOG_D(TAG, "Protocol-TYPE %d", proto->type);
     if(proto && proto->type == SubGhzProtocolTypeDynamic) {
         FURI_LOG_D(TAG, "Protocol is dynamic. Saving key");
-        unirfremix_save_protocol_to_file(app->tx_fff_data, app->tx_file_path);
+        subghz_remote_save_protocol_to_file(app->tx_fff_data, app->tx_file_path);
 
         keeloq_reset_mfname();
         keeloq_reset_kl_type();
@@ -497,22 +500,22 @@ void unirfremix_tx_stop(UniRFRemix* app) {
 
     notification_message(app->notification, &sequence_blink_stop);
 
-    unirfremix_preset_free(app->txpreset);
+    subghz_remote_preset_free(app->txpreset);
     flipper_format_free(app->tx_fff_data);
-    unirfremix_end_send(app);
+    subghz_remote_end_send(app);
 }
 
-static bool unirfremix_send_sub(UniRFRemix* app, FlipperFormat* fff_data) {
+static bool subghz_remote_send_sub(SubGHzRemote* app, FlipperFormat* fff_data) {
     //
     bool res = false;
     do {
         if(!furi_hal_subghz_is_tx_allowed(app->txpreset->frequency)) {
             printf(
                 "In your settings, only reception on this frequency (%lu) is allowed,\r\n"
-                "the actual operation of the unirf app is not possible\r\n ",
+                "the actual operation of the subghz remote app is not possible\r\n ",
                 app->txpreset->frequency);
             app->tx_not_allowed = true;
-            unirfremix_end_send(app);
+            subghz_remote_end_send(app);
             break;
         } else {
             app->tx_not_allowed = false;
@@ -554,14 +557,14 @@ static bool unirfremix_send_sub(UniRFRemix* app, FlipperFormat* fff_data) {
     return res;
 }
 
-static void unirfremix_send_signal(UniRFRemix* app, Storage* storage, const char* path) {
+static void subghz_remote_send_signal(SubGHzRemote* app, Storage* storage, const char* path) {
     FURI_LOG_D(TAG, "Sending: %s", path);
 
     app->tx_file_path = path;
 
     app->tx_fff_data = flipper_format_string_alloc();
 
-    app->txpreset = unirfremix_preset_alloc();
+    app->txpreset = subghz_remote_preset_alloc();
 
     // load settings/stream from .sub file
     FlipperFormat* fff_file = flipper_format_file_alloc(storage);
@@ -571,7 +574,7 @@ static void unirfremix_send_signal(UniRFRemix* app, Storage* storage, const char
             FURI_LOG_E(TAG, "Could not open file %s", path);
             break;
         }
-        if(!unirfremix_key_load(
+        if(!subghz_remote_key_load(
                app->txpreset,
                fff_file,
                app->tx_fff_data,
@@ -589,25 +592,25 @@ static void unirfremix_send_signal(UniRFRemix* app, Storage* storage, const char
         return;
     }
 
-    unirfremix_send_sub(app, app->tx_fff_data);
+    subghz_remote_send_sub(app, app->tx_fff_data);
 }
 
-static void unirfremix_process_signal(UniRFRemix* app, FuriString* signal) {
+static void subghz_remote_process_signal(SubGHzRemote* app, FuriString* signal) {
     view_port_update(app->view_port);
 
     FURI_LOG_D(TAG, "signal = %s", furi_string_get_cstr(signal));
 
     if(strlen(furi_string_get_cstr(signal)) > 12) {
         Storage* storage = furi_record_open(RECORD_STORAGE);
-        unirfremix_send_signal(app, storage, furi_string_get_cstr(signal));
+        subghz_remote_send_signal(app, storage, furi_string_get_cstr(signal));
         furi_record_close(RECORD_STORAGE);
     } else if(strlen(furi_string_get_cstr(signal)) < 10) {
-        unirfremix_end_send(app);
+        subghz_remote_end_send(app);
     }
 }
 
 static void render_callback(Canvas* canvas, void* ctx) {
-    UniRFRemix* app = ctx;
+    SubGHzRemote* app = ctx;
     furi_check(furi_mutex_acquire(app->model_mutex, FuriWaitForever) == FuriStatusOk);
 
     //setup different canvas settings
@@ -647,10 +650,10 @@ static void render_callback(Canvas* canvas, void* ctx) {
         //canvas_draw_str(canvas, 0, 40, "D: ");
         //canvas_draw_str(canvas, 0, 50, "Ok: ");
 
-        //PNGs are located in assets/icons/UniRFRemix before compilation
+        //PNGs are located in assets/icons/SubGHzRemote before compilation
 
         //Icons for Labels
-        //canvas_draw_icon(canvas, 0, 0, &I_UniRFRemix_LeftAlignedButtons_9x64);
+        //canvas_draw_icon(canvas, 0, 0, &I_SubGHzRemote_LeftAlignedButtons_9x64);
         canvas_draw_icon(canvas, 1, 5, &I_ButtonUp_7x4);
         canvas_draw_icon(canvas, 1, 15, &I_ButtonDown_7x4);
         canvas_draw_icon(canvas, 2, 23, &I_ButtonLeft_4x7);
@@ -699,7 +702,7 @@ static void render_callback(Canvas* canvas, void* ctx) {
 
         //Repeat indicator
         //canvas_draw_str_aligned(canvas, 125, 40, AlignRight, AlignBottom, "Repeat:");
-        //canvas_draw_icon(canvas, 115, 39, &I_UniRFRemix_Repeat_12x14);
+        //canvas_draw_icon(canvas, 115, 39, &I_SubGHzRemote_Repeat_12x14);
         //canvas_draw_str_aligned(canvas, 125, 62, AlignRight, AlignBottom, int_to_char(app->repeat));
     }
 
@@ -707,11 +710,11 @@ static void render_callback(Canvas* canvas, void* ctx) {
 }
 
 static void input_callback(InputEvent* input_event, void* ctx) {
-    UniRFRemix* app = ctx;
+    SubGHzRemote* app = ctx;
     furi_message_queue_put(app->input_queue, input_event, 0);
 }
 
-void unirfremix_subghz_alloc(UniRFRemix* app) {
+void subghz_remote_subghz_alloc(SubGHzRemote* app) {
     // load subghz presets
     app->setting = subghz_setting_alloc();
     subghz_setting_load(app->setting, EXT_PATH("subghz/assets/setting_user"));
@@ -730,8 +733,11 @@ void unirfremix_subghz_alloc(UniRFRemix* app) {
     app->subghz_receiver = subghz_receiver_alloc_init(app->environment);
 }
 
-UniRFRemix* unirfremix_alloc(void) {
-    UniRFRemix* app = malloc(sizeof(UniRFRemix));
+SubGHzRemote* subghz_remote_alloc(void) {
+    SubGHzRemote* app = malloc(sizeof(SubGHzRemote));
+
+    // Enable power for External CC1101 if it is connected
+    furi_hal_subghz_enable_ext_power();
 
     furi_hal_power_suppress_charge_enter();
 
@@ -752,9 +758,12 @@ UniRFRemix* unirfremix_alloc(void) {
     return app;
 }
 
-void unirfremix_free(UniRFRemix* app, bool with_subghz) {
+void subghz_remote_free(SubGHzRemote* app, bool with_subghz) {
     furi_hal_power_suppress_charge_exit();
 
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
+
     furi_string_free(app->up_file);
     furi_string_free(app->down_file);
     furi_string_free(app->left_file);
@@ -786,9 +795,9 @@ void unirfremix_free(UniRFRemix* app, bool with_subghz) {
     free(app);
 }
 
-int32_t unirfremix_app(void* p) {
+int32_t subghz_remote_app(void* p) {
     UNUSED(p);
-    UniRFRemix* app = unirfremix_alloc();
+    SubGHzRemote* app = subghz_remote_alloc();
 
     app->file_path = furi_string_alloc();
     app->signal = furi_string_alloc();
@@ -803,33 +812,35 @@ int32_t unirfremix_app(void* p) {
     app->file_result = 3;
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
-    if(!storage_simply_mkdir(storage, UNIRFMAP_FOLDER)) {
-        FURI_LOG_E(TAG, "Could not create folder %s", UNIRFMAP_FOLDER);
+    storage_common_migrate(storage, EXT_PATH("unirf"), SUBREMOTEMAP_FOLDER);
+
+    if(!storage_simply_mkdir(storage, SUBREMOTEMAP_FOLDER)) {
+        FURI_LOG_E(TAG, "Could not create folder %s", SUBREMOTEMAP_FOLDER);
     }
     furi_record_close(RECORD_STORAGE);
 
-    furi_string_set(app->file_path, UNIRFMAP_FOLDER);
+    furi_string_set(app->file_path, SUBREMOTEMAP_FOLDER);
 
     DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
 
     DialogsFileBrowserOptions browser_options;
-    dialog_file_browser_set_basic_options(&browser_options, UNIRFMAP_EXTENSION, &I_sub1_10px);
-    browser_options.base_path = UNIRFMAP_FOLDER;
+    dialog_file_browser_set_basic_options(&browser_options, SUBREMOTEMAP_EXTENSION, &I_sub1_10px);
+    browser_options.base_path = SUBREMOTEMAP_FOLDER;
 
     bool res = dialog_file_browser_show(dialogs, app->file_path, app->file_path, &browser_options);
 
     furi_record_close(RECORD_DIALOGS);
     if(!res) {
         FURI_LOG_E(TAG, "No file selected");
-        unirfremix_free(app, false);
+        subghz_remote_free(app, false);
         return 255;
     } else {
         //check map and population variables
-        unirfremix_cfg_set_check(app, app->file_path);
+        subghz_remote_cfg_set_check(app, app->file_path);
     }
 
     // init subghz stuff
-    unirfremix_subghz_alloc(app);
+    subghz_remote_subghz_alloc(app);
 
     bool exit_loop = false;
 
@@ -879,7 +890,7 @@ int32_t unirfremix_app(void* p) {
                 }
                 if(input.type == InputTypeRelease) {
                     if(app->up_enabled) {
-                        unirfremix_tx_stop(app);
+                        subghz_remote_tx_stop(app);
                     }
                 }
                 break;
@@ -897,7 +908,7 @@ int32_t unirfremix_app(void* p) {
                 }
                 if(input.type == InputTypeRelease) {
                     if(app->down_enabled) {
-                        unirfremix_tx_stop(app);
+                        subghz_remote_tx_stop(app);
                     }
                 }
                 break;
@@ -915,7 +926,7 @@ int32_t unirfremix_app(void* p) {
                 }
                 if(input.type == InputTypeRelease) {
                     if(app->right_enabled) {
-                        unirfremix_tx_stop(app);
+                        subghz_remote_tx_stop(app);
                     }
                 }
                 break;
@@ -933,7 +944,7 @@ int32_t unirfremix_app(void* p) {
                 }
                 if(input.type == InputTypeRelease) {
                     if(app->left_enabled) {
-                        unirfremix_tx_stop(app);
+                        subghz_remote_tx_stop(app);
                     }
                 }
                 break;
@@ -951,13 +962,13 @@ int32_t unirfremix_app(void* p) {
                 }
                 if(input.type == InputTypeRelease) {
                     if(app->ok_enabled) {
-                        unirfremix_tx_stop(app);
+                        subghz_remote_tx_stop(app);
                     }
                 }
                 break;
 
             case InputKeyBack:
-                unirfremix_tx_stop(app);
+                subghz_remote_tx_stop(app);
                 exit_loop = true;
                 break;
             default:
@@ -994,7 +1005,7 @@ int32_t unirfremix_app(void* p) {
 
                 app->processing = 2;
 
-                unirfremix_process_signal(app, app->signal);
+                subghz_remote_process_signal(app, app->signal);
             }
 
             if(exit_loop == true) {
@@ -1050,7 +1061,7 @@ int32_t unirfremix_app(void* p) {
     }
 
     // remove & free all stuff created by app
-    unirfremix_free(app, true);
+    subghz_remote_free(app, true);
 
     return 0;
 }
diff --git a/applications/plugins/arkanoid/arkanoid_game.c b/applications/plugins/arkanoid/arkanoid_game.c
index 0b9bb91e97..a8b8465790 100644
--- a/applications/plugins/arkanoid/arkanoid_game.c
+++ b/applications/plugins/arkanoid/arkanoid_game.c
@@ -38,6 +38,7 @@ typedef struct {
 } BallState;
 
 typedef struct {
+    FuriMutex* mutex;
     BallState ball_state;
     BrickState brick_state;
     NotificationApp* notify;
@@ -310,10 +311,9 @@ static void arkanoid_state_init(ArkanoidState* arkanoid_state) {
 }
 
 static void arkanoid_draw_callback(Canvas* const canvas, void* ctx) {
-    ArkanoidState* arkanoid_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(arkanoid_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    ArkanoidState* arkanoid_state = ctx;
+    furi_mutex_acquire(arkanoid_state->mutex, FuriWaitForever);
 
     //Initial level draw
     if(!arkanoid_state->initialDraw) {
@@ -352,7 +352,7 @@ static void arkanoid_draw_callback(Canvas* const canvas, void* ctx) {
         arkanoid_state->score = 0;
     }
 
-    release_mutex((ValueMutex*)ctx, arkanoid_state);
+    furi_mutex_release(arkanoid_state->mutex);
 }
 
 static void arkanoid_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -378,8 +378,8 @@ int32_t arkanoid_game_app(void* p) {
     ArkanoidState* arkanoid_state = malloc(sizeof(ArkanoidState));
     arkanoid_state_init(arkanoid_state);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, arkanoid_state, sizeof(ArkanoidState))) {
+    arkanoid_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!arkanoid_state->mutex) {
         FURI_LOG_E(TAG, "Cannot create mutex\r\n");
         return_code = 255;
         goto free_and_exit;
@@ -387,7 +387,7 @@ int32_t arkanoid_game_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, arkanoid_draw_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, arkanoid_draw_callback, arkanoid_state);
     view_port_input_callback_set(view_port, arkanoid_input_callback, event_queue);
 
     FuriTimer* timer =
@@ -404,7 +404,7 @@ int32_t arkanoid_game_app(void* p) {
     GameEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        ArkanoidState* arkanoid_state = (ArkanoidState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(arkanoid_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // Key events
@@ -461,7 +461,7 @@ int32_t arkanoid_game_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, arkanoid_state);
+        furi_mutex_release(arkanoid_state->mutex);
     }
     furi_timer_free(timer);
     view_port_enabled_set(view_port, false);
@@ -469,7 +469,7 @@ int32_t arkanoid_game_app(void* p) {
     furi_record_close(RECORD_GUI);
     furi_record_close(RECORD_NOTIFICATION);
     view_port_free(view_port);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(arkanoid_state->mutex);
 
 free_and_exit:
     free(arkanoid_state);
diff --git a/applications/plugins/barcode_generator/barcode_generator.c b/applications/plugins/barcode_generator/barcode_generator.c
index cbbb416716..2645bbceac 100644
--- a/applications/plugins/barcode_generator/barcode_generator.c
+++ b/applications/plugins/barcode_generator/barcode_generator.c
@@ -130,10 +130,9 @@ int calculate_check_digit(PluginState* plugin_state, BarcodeType* type) {
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(plugin_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
     if(plugin_state->mode == MenuMode) {
         canvas_set_color(canvas, ColorBlack);
@@ -239,7 +238,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         canvas_draw_box(canvas, (endSafetyPosition + 2), BARCODE_Y_START, 1, BARCODE_HEIGHT + 2);
     }
 
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -387,8 +386,9 @@ int32_t barcode_generator_app(void* p) {
 
     PluginState* plugin_state = malloc(sizeof(PluginState));
     barcode_generator_state_init(plugin_state);
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         FURI_LOG_E("barcode_generator", "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(plugin_state);
@@ -397,7 +397,7 @@ int32_t barcode_generator_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -407,7 +407,7 @@ int32_t barcode_generator_app(void* p) {
     PluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -430,7 +430,7 @@ int32_t barcode_generator_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
+        furi_mutex_release(plugin_state->mutex);
     }
 
     view_port_enabled_set(view_port, false);
@@ -438,6 +438,7 @@ int32_t barcode_generator_app(void* p) {
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
+    furi_mutex_free(plugin_state->mutex);
     // save settings
     SAVE_BARCODE_SETTINGS(&plugin_state->barcode_state);
     free(plugin_state);
diff --git a/applications/plugins/barcode_generator/barcode_generator.h b/applications/plugins/barcode_generator/barcode_generator.h
index b39e433207..5d2c8307e9 100644
--- a/applications/plugins/barcode_generator/barcode_generator.h
+++ b/applications/plugins/barcode_generator/barcode_generator.h
@@ -81,6 +81,7 @@ typedef struct {
 } BarcodeState;
 
 typedef struct {
+    FuriMutex* mutex;
     BarcodeState barcode_state;
     int editingIndex; //The index of the editing symbol
     int menuIndex; //The index of the menu cursor
diff --git a/applications/plugins/blackjack/blackjack.c b/applications/plugins/blackjack/blackjack.c
index 7e62ec5398..95f9c72bb6 100644
--- a/applications/plugins/blackjack/blackjack.c
+++ b/applications/plugins/blackjack/blackjack.c
@@ -33,11 +33,9 @@ static void draw_ui(Canvas* const canvas, const GameState* game_state) {
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const GameState* game_state = acquire_mutex((ValueMutex*)ctx, 25);
-
-    if(game_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const GameState* game_state = ctx;
+    furi_mutex_acquire(game_state->mutex, FuriWaitForever);
 
     canvas_set_color(canvas, ColorBlack);
     canvas_draw_frame(canvas, 0, 0, 128, 64);
@@ -60,7 +58,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         settings_page(canvas, game_state);
     }
 
-    release_mutex((ValueMutex*)ctx, game_state);
+    furi_mutex_release(game_state->mutex);
 }
 
 //region card draw
@@ -553,21 +551,21 @@ int32_t blackjack_app(void* p) {
 
     game_state->state = GameStateStart;
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, game_state, sizeof(GameState))) {
+    game_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!game_state->mutex) {
         FURI_LOG_E(APP_NAME, "cannot create mutex\r\n");
         return_code = 255;
         goto free_and_exit;
     }
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, game_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     FuriTimer* timer = furi_timer_alloc(update_timer_callback, FuriTimerTypePeriodic, event_queue);
     furi_timer_start(timer, furi_kernel_get_tick_frequency() / 25);
 
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     AppEvent event;
@@ -577,47 +575,44 @@ int32_t blackjack_app(void* p) {
 
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        GameState* localstate = (GameState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(game_state->mutex, FuriWaitForever);
         if(event_status == FuriStatusOk) {
             if(event.type == EventTypeKey) {
                 if(event.input.type == InputTypePress) {
                     switch(event.input.key) {
                     case InputKeyUp:
-                        localstate->selectDirection = DirectionUp;
+                        game_state->selectDirection = DirectionUp;
                         break;
                     case InputKeyDown:
-                        localstate->selectDirection = DirectionDown;
+                        game_state->selectDirection = DirectionDown;
                         break;
                     case InputKeyRight:
-                        localstate->selectDirection = DirectionRight;
+                        game_state->selectDirection = DirectionRight;
                         break;
                     case InputKeyLeft:
-                        localstate->selectDirection = DirectionLeft;
+                        game_state->selectDirection = DirectionLeft;
                         break;
                     case InputKeyBack:
-                        if(localstate->state == GameStateSettings) {
-                            localstate->state = GameStateStart;
-                            save_settings(localstate->settings);
+                        if(game_state->state == GameStateSettings) {
+                            game_state->state = GameStateStart;
+                            save_settings(game_state->settings);
                         } else
                             processing = false;
                         break;
                     case InputKeyOk:
-                        localstate->selectDirection = Select;
+                        game_state->selectDirection = Select;
                         break;
                     default:
                         break;
                     }
                 }
             } else if(event.type == EventTypeTick) {
-                tick(localstate);
-                processing = localstate->processing;
+                tick(game_state);
+                processing = game_state->processing;
             }
-        } else {
-            //FURI_LOG_D(APP_NAME, "osMessageQueue: event timeout");
-            // event timeout
         }
         view_port_update(view_port);
-        release_mutex(&state_mutex, localstate);
+        furi_mutex_release(game_state->mutex);
     }
 
     furi_timer_free(timer);
@@ -625,7 +620,7 @@ int32_t blackjack_app(void* p) {
     gui_remove_view_port(gui, view_port);
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(game_state->mutex);
 
 free_and_exit:
     free(game_state->deck.cards);
diff --git a/applications/plugins/blackjack/common/card.c b/applications/plugins/blackjack/common/card.c
index 199135bb5a..88228fda44 100644
--- a/applications/plugins/blackjack/common/card.c
+++ b/applications/plugins/blackjack/common/card.c
@@ -173,7 +173,7 @@ uint8_t hand_count(const Card* cards, uint8_t count) {
     }
 
     for(uint8_t i = 0; i < aceCount; i++) {
-        if((score + 11) <= 21)
+        if((score + 11 + (aceCount - 1)) <= 21)
             score += 11;
         else
             score++;
@@ -350,4 +350,4 @@ void add_hand_region(Hand* to, Hand* from) {
             add_to_hand(to, from->cards[i]);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/applications/plugins/blackjack/defines.h b/applications/plugins/blackjack/defines.h
index b400badfbc..0a3fdf53e6 100644
--- a/applications/plugins/blackjack/defines.h
+++ b/applications/plugins/blackjack/defines.h
@@ -54,6 +54,7 @@ typedef enum {
 } Direction;
 
 typedef struct {
+    FuriMutex* mutex;
     Card player_cards[21];
     Card dealer_cards[21];
     uint8_t player_card_count;
diff --git a/applications/plugins/doom/doom.c b/applications/plugins/doom/doom.c
index 822f9b6fc4..2fb99a635b 100644
--- a/applications/plugins/doom/doom.c
+++ b/applications/plugins/doom/doom.c
@@ -38,6 +38,7 @@ typedef struct {
 } PluginEvent;
 
 typedef struct {
+    FuriMutex* mutex;
     Player player;
     Entity entity[MAX_ENTITIES];
     StaticEntity static_entity[MAX_STATIC_ENTITIES];
@@ -765,10 +766,9 @@ void loopIntro(Canvas* const canvas) {
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(plugin_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
     if(plugin_state->init) setupDisplay(canvas);
 
     canvas_set_font(canvas, FontPrimary);
@@ -792,7 +792,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         break;
     }
     }
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -962,8 +962,8 @@ int32_t doom_app() {
     FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
     PluginState* plugin_state = malloc(sizeof(PluginState));
     doom_state_init(plugin_state);
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         FURI_LOG_E("Doom_game", "cannot create mutex\r\n");
         furi_record_close(RECORD_NOTIFICATION);
         furi_message_queue_free(event_queue);
@@ -975,11 +975,11 @@ int32_t doom_app() {
     furi_timer_start(timer, furi_kernel_get_tick_frequency() / 12);
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // Open GUI and register view_port
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     //////////////////////////////////
@@ -995,7 +995,7 @@ int32_t doom_app() {
 
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 #ifdef SOUND
         furi_check(
             furi_mutex_acquire(plugin_state->music_instance->model_mutex, FuriWaitForever) ==
@@ -1085,7 +1085,7 @@ int32_t doom_app() {
         furi_mutex_release(plugin_state->music_instance->model_mutex);
 #endif
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
+        furi_mutex_release(plugin_state->mutex);
     }
 #ifdef SOUND
     music_player_worker_free(plugin_state->music_instance->worker);
@@ -1097,8 +1097,9 @@ int32_t doom_app() {
     furi_timer_free(timer);
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
-    furi_record_close("gui");
+    furi_record_close(RECORD_GUI);
     view_port_free(view_port);
+    furi_mutex_free(plugin_state->mutex);
     furi_message_queue_free(event_queue);
     free(plugin_state);
     return 0;
diff --git a/applications/plugins/esp8266_deauth/esp8266_deauth.c b/applications/plugins/esp8266_deauth/esp8266_deauth.c
index 3cc61a5886..d32ca4c18f 100644
--- a/applications/plugins/esp8266_deauth/esp8266_deauth.c
+++ b/applications/plugins/esp8266_deauth/esp8266_deauth.c
@@ -62,6 +62,7 @@ typedef struct SGpioButtons {
 } SGpioButtons;
 
 typedef struct SWiFiDeauthApp {
+    FuriMutex* mutex;
     Gui* m_gui;
     FuriThread* m_worker_thread;
     //NotificationApp* m_notification;
@@ -121,10 +122,9 @@ static void esp8266_deauth_app_init(SWiFiDeauthApp* const app) {
 }
 
 static void esp8266_deauth_module_render_callback(Canvas* const canvas, void* ctx) {
-    SWiFiDeauthApp* app = acquire_mutex((ValueMutex*)ctx, 25);
-    if(app == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    SWiFiDeauthApp* app = ctx;
+    furi_mutex_acquire(app->mutex, FuriWaitForever);
 
     //if(app->m_needUpdateGUI)
     //{
@@ -206,7 +206,7 @@ static void esp8266_deauth_module_render_callback(Canvas* const canvas, void* ct
         break;
     }
 
-    release_mutex((ValueMutex*)ctx, app);
+    furi_mutex_release(app->mutex);
 }
 
 static void
@@ -235,14 +235,15 @@ static int32_t uart_worker(void* context) {
     furi_assert(context);
     DEAUTH_APP_LOG_I("[UART] Worker thread init");
 
-    SWiFiDeauthApp* app = acquire_mutex((ValueMutex*)context, 25);
+    SWiFiDeauthApp* app = context;
+    furi_mutex_acquire(app->mutex, FuriWaitForever);
     if(app == NULL) {
         return 1;
     }
 
     FuriStreamBuffer* rx_stream = app->m_rx_stream;
 
-    release_mutex((ValueMutex*)context, app);
+    furi_mutex_release(app->mutex);
 
 #if ENABLE_MODULE_POWER
     bool initialized = false;
@@ -259,7 +260,8 @@ static int32_t uart_worker(void* context) {
         if(events & WorkerEventStop) break;
         if(events & WorkerEventRx) {
             DEAUTH_APP_LOG_I("[UART] Received data");
-            SWiFiDeauthApp* app = acquire_mutex((ValueMutex*)context, 25);
+            SWiFiDeauthApp* app = context;
+            furi_mutex_acquire(app->mutex, FuriWaitForever);
             if(app == NULL) {
                 return 1;
             }
@@ -307,7 +309,7 @@ static int32_t uart_worker(void* context) {
             }
 #endif // ENABLE_MODULE_POWER
 
-            release_mutex((ValueMutex*)context, app);
+            furi_mutex_release(app->mutex);
         }
     }
 
@@ -356,8 +358,8 @@ int32_t esp8266_deauth_app(void* p) {
 #endif
 #endif // ENABLE_MODULE_DETECTION
 
-    ValueMutex app_data_mutex;
-    if(!init_mutex(&app_data_mutex, app, sizeof(SWiFiDeauthApp))) {
+    app->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!app->mutex) {
         DEAUTH_APP_LOG_E("cannot create mutex\r\n");
         free(app);
         return 255;
@@ -365,10 +367,10 @@ int32_t esp8266_deauth_app(void* p) {
 
     DEAUTH_APP_LOG_I("Mutex created");
 
-    //app->m_notification = furi_record_open("notification");
+    //app->m_notification = furi_record_open(RECORD_NOTIFICATION);
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, esp8266_deauth_module_render_callback, &app_data_mutex);
+    view_port_draw_callback_set(view_port, esp8266_deauth_module_render_callback, app);
     view_port_input_callback_set(view_port, esp8266_deauth_module_input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -382,7 +384,7 @@ int32_t esp8266_deauth_app(void* p) {
     app->m_worker_thread = furi_thread_alloc();
     furi_thread_set_name(app->m_worker_thread, "WiFiDeauthModuleUARTWorker");
     furi_thread_set_stack_size(app->m_worker_thread, 1 * 1024);
-    furi_thread_set_context(app->m_worker_thread, &app_data_mutex);
+    furi_thread_set_context(app->m_worker_thread, app);
     furi_thread_set_callback(app->m_worker_thread, uart_worker);
     furi_thread_start(app->m_worker_thread);
     DEAUTH_APP_LOG_I("UART thread allocated");
@@ -398,7 +400,7 @@ int32_t esp8266_deauth_app(void* p) {
     SPluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        SWiFiDeauthApp* app = (SWiFiDeauthApp*)acquire_mutex_block(&app_data_mutex);
+        furi_mutex_acquire(app->mutex, FuriWaitForever);
 
 #if ENABLE_MODULE_DETECTION
         if(!app->m_wifiDeauthModuleAttached) {
@@ -484,7 +486,7 @@ int32_t esp8266_deauth_app(void* p) {
 #endif
 
         view_port_update(view_port);
-        release_mutex(&app_data_mutex, app);
+        furi_mutex_release(app->mutex);
     }
 
     DEAUTH_APP_LOG_I("Start exit app");
@@ -514,7 +516,7 @@ int32_t esp8266_deauth_app(void* p) {
 
     // Close gui record
     furi_record_close(RECORD_GUI);
-    furi_record_close("notification");
+    //furi_record_close(RECORD_NOTIFICATION);
     app->m_gui = NULL;
 
     view_port_free(view_port);
@@ -523,7 +525,7 @@ int32_t esp8266_deauth_app(void* p) {
 
     furi_stream_buffer_free(app->m_rx_stream);
 
-    delete_mutex(&app_data_mutex);
+    furi_mutex_free(app->mutex);
 
     // Free rest
     free(app);
diff --git a/applications/plugins/flappy_bird/flappy_bird.c b/applications/plugins/flappy_bird/flappy_bird.c
index 0ff6f186ac..b264d1b70f 100644
--- a/applications/plugins/flappy_bird/flappy_bird.c
+++ b/applications/plugins/flappy_bird/flappy_bird.c
@@ -60,6 +60,7 @@ typedef struct {
     PILAR pilars[FLAPPY_PILAR_MAX];
     bool debug;
     State state;
+    FuriMutex* mutex;
 } GameState;
 
 typedef struct {
@@ -175,10 +176,9 @@ static void flappy_game_flap(GameState* const game_state) {
 }
 
 static void flappy_game_render_callback(Canvas* const canvas, void* ctx) {
-    const GameState* game_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(game_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const GameState* game_state = ctx;
+    furi_mutex_acquire(game_state->mutex, FuriWaitForever);
 
     canvas_draw_frame(canvas, 0, 0, 128, 64);
 
@@ -262,7 +262,7 @@ static void flappy_game_render_callback(Canvas* const canvas, void* ctx) {
         canvas_draw_str_aligned(canvas, 64, 41, AlignCenter, AlignBottom, buffer);
     }
 
-    release_mutex((ValueMutex*)ctx, game_state);
+    furi_mutex_release(game_state->mutex);
 }
 
 static void flappy_game_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -288,8 +288,8 @@ int32_t flappy_game_app(void* p) {
     GameState* game_state = malloc(sizeof(GameState));
     flappy_game_state_init(game_state);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, game_state, sizeof(GameState))) {
+    game_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!game_state->mutex) {
         FURI_LOG_E(TAG, "cannot create mutex\r\n");
         return_code = 255;
         goto free_and_exit;
@@ -297,7 +297,7 @@ int32_t flappy_game_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, flappy_game_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, flappy_game_render_callback, game_state);
     view_port_input_callback_set(view_port, flappy_game_input_callback, event_queue);
 
     FuriTimer* timer =
@@ -314,7 +314,7 @@ int32_t flappy_game_app(void* p) {
     GameEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        GameState* game_state = (GameState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(game_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -356,7 +356,7 @@ int32_t flappy_game_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, game_state);
+        furi_mutex_release(game_state->mutex);
     }
 
     furi_timer_free(timer);
@@ -364,7 +364,7 @@ int32_t flappy_game_app(void* p) {
     gui_remove_view_port(gui, view_port);
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(game_state->mutex);
 
 free_and_exit:
     flappy_game_state_free(game_state);
diff --git a/applications/plugins/flipfrid/flipfrid.c b/applications/plugins/flipfrid/flipfrid.c
index 2c5d1201d8..9ddbdd42e9 100644
--- a/applications/plugins/flipfrid/flipfrid.c
+++ b/applications/plugins/flipfrid/flipfrid.c
@@ -9,11 +9,9 @@
 #define RFIDFUZZER_APP_FOLDER "/ext/rfidfuzzer"
 
 static void flipfrid_draw_callback(Canvas* const canvas, void* ctx) {
-    FlipFridState* flipfrid_state = (FlipFridState*)acquire_mutex((ValueMutex*)ctx, 100);
-
-    if(flipfrid_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    FlipFridState* flipfrid_state = ctx;
+    furi_mutex_acquire(flipfrid_state->mutex, FuriWaitForever);
 
     // Draw correct Canvas
     switch(flipfrid_state->current_scene) {
@@ -35,7 +33,7 @@ static void flipfrid_draw_callback(Canvas* const canvas, void* ctx) {
         break;
     }
 
-    release_mutex((ValueMutex*)ctx, flipfrid_state);
+    furi_mutex_release(flipfrid_state->mutex);
 }
 
 void flipfrid_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -116,11 +114,9 @@ int32_t flipfrid_start(void* p) {
     FURI_LOG_I(TAG, "Initializing input");
     FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(FlipFridEvent));
     FlipFridState* flipfrid_state = flipfrid_alloc();
-    ValueMutex flipfrid_state_mutex;
 
-    // Mutex
-    FURI_LOG_I(TAG, "Initializing flipfrid mutex");
-    if(!init_mutex(&flipfrid_state_mutex, flipfrid_state, sizeof(FlipFridState))) {
+    flipfrid_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!flipfrid_state->mutex) {
         FURI_LOG_E(TAG, "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         furi_record_close(RECORD_NOTIFICATION);
@@ -137,7 +133,7 @@ int32_t flipfrid_start(void* p) {
     // Configure view port
     FURI_LOG_I(TAG, "Initializing viewport");
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, flipfrid_draw_callback, &flipfrid_state_mutex);
+    view_port_draw_callback_set(view_port, flipfrid_draw_callback, flipfrid_state);
     view_port_input_callback_set(view_port, flipfrid_input_callback, event_queue);
 
     // Configure timer
@@ -258,6 +254,7 @@ int32_t flipfrid_start(void* p) {
     furi_message_queue_free(event_queue);
     furi_record_close(RECORD_GUI);
     furi_record_close(RECORD_NOTIFICATION);
+    furi_mutex_free(flipfrid_state->mutex);
     flipfrid_free(flipfrid_state);
 
     return 0;
diff --git a/applications/plugins/flipfrid/flipfrid.h b/applications/plugins/flipfrid/flipfrid.h
index 6b8662e659..e4122054b3 100644
--- a/applications/plugins/flipfrid/flipfrid.h
+++ b/applications/plugins/flipfrid/flipfrid.h
@@ -58,6 +58,7 @@ typedef struct {
 
 // STRUCTS
 typedef struct {
+    FuriMutex* mutex;
     bool is_running;
     bool is_attacking;
     FlipFridScene current_scene;
diff --git a/applications/plugins/flipper_i2ctools/i2ctools.c b/applications/plugins/flipper_i2ctools/i2ctools.c
index 9d73a73b8f..6d4cc739fa 100644
--- a/applications/plugins/flipper_i2ctools/i2ctools.c
+++ b/applications/plugins/flipper_i2ctools/i2ctools.c
@@ -1,7 +1,9 @@
 #include "i2ctools_i.h"
 
 void i2ctools_draw_callback(Canvas* canvas, void* ctx) {
-    i2cTools* i2ctools = acquire_mutex((ValueMutex*)ctx, 25);
+    furi_assert(ctx);
+    i2cTools* i2ctools = ctx;
+    furi_mutex_acquire(i2ctools->mutex, FuriWaitForever);
 
     switch(i2ctools->main_view->current_view) {
     case MAIN_VIEW:
@@ -23,7 +25,7 @@ void i2ctools_draw_callback(Canvas* canvas, void* ctx) {
     default:
         break;
     }
-    release_mutex((ValueMutex*)ctx, i2ctools);
+    furi_mutex_release(i2ctools->mutex);
 }
 
 void i2ctools_input_callback(InputEvent* input_event, void* ctx) {
@@ -38,8 +40,8 @@ int32_t i2ctools_app(void* p) {
 
     // Alloc i2ctools
     i2cTools* i2ctools = malloc(sizeof(i2cTools));
-    ValueMutex i2ctools_mutex;
-    if(!init_mutex(&i2ctools_mutex, i2ctools, sizeof(i2cTools))) {
+    i2ctools->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!i2ctools->mutex) {
         FURI_LOG_E(APP_NAME, "cannot create mutex\r\n");
         free(i2ctools);
         return -1;
@@ -47,7 +49,7 @@ int32_t i2ctools_app(void* p) {
 
     // Alloc viewport
     i2ctools->view_port = view_port_alloc();
-    view_port_draw_callback_set(i2ctools->view_port, i2ctools_draw_callback, &i2ctools_mutex);
+    view_port_draw_callback_set(i2ctools->view_port, i2ctools_draw_callback, i2ctools);
     view_port_input_callback_set(i2ctools->view_port, i2ctools_input_callback, event_queue);
 
     // Register view port in GUI
@@ -216,6 +218,7 @@ int32_t i2ctools_app(void* p) {
     i2c_scanner_free(i2ctools->scanner);
     i2c_sender_free(i2ctools->sender);
     i2c_main_view_free(i2ctools->main_view);
+    furi_mutex_free(i2ctools->mutex);
     free(i2ctools);
     furi_record_close(RECORD_GUI);
     return 0;
diff --git a/applications/plugins/flipper_i2ctools/i2ctools_i.h b/applications/plugins/flipper_i2ctools/i2ctools_i.h
index 33917dc34d..f31e424785 100644
--- a/applications/plugins/flipper_i2ctools/i2ctools_i.h
+++ b/applications/plugins/flipper_i2ctools/i2ctools_i.h
@@ -13,6 +13,7 @@
 
 // App datas
 typedef struct {
+    FuriMutex* mutex;
     ViewPort* view_port;
     i2cMainView* main_view;
 
diff --git a/applications/plugins/game_2048/game_2048.c b/applications/plugins/game_2048/game_2048.c
index 1a2f4a4d33..a1e6361b63 100644
--- a/applications/plugins/game_2048/game_2048.c
+++ b/applications/plugins/game_2048/game_2048.c
@@ -34,6 +34,7 @@ typedef enum {
 } State;
 
 typedef struct {
+    FuriMutex* mutex;
     State state;
     uint8_t table[CELLS_COUNT][CELLS_COUNT];
     uint32_t score;
@@ -104,8 +105,9 @@ static void gray_canvas(Canvas* const canvas) {
 }
 
 static void draw_callback(Canvas* const canvas, void* ctx) {
-    const GameState* game_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(game_state == NULL) return;
+    furi_assert(ctx);
+    const GameState* game_state = ctx;
+    furi_mutex_acquire(game_state->mutex, FuriWaitForever);
 
     canvas_clear(canvas);
 
@@ -181,7 +183,7 @@ static void draw_callback(Canvas* const canvas, void* ctx) {
         canvas_draw_str_aligned(canvas, 64, 48, AlignCenter, AlignBottom, buf);
     }
 
-    release_mutex((ValueMutex*)ctx, game_state);
+    furi_mutex_release(game_state->mutex);
 }
 
 void calculate_move_to_left(uint8_t arr[], MoveResult* const move_result) {
@@ -381,8 +383,8 @@ int32_t game_2048_app() {
 
     MoveResult* move_result = malloc(sizeof(MoveResult));
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, game_state, sizeof(GameState))) {
+    game_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!game_state->mutex) {
         FURI_LOG_E("2048Game", "cannot create mutex\r\n");
         free(game_state);
         return 255;
@@ -392,7 +394,7 @@ int32_t game_2048_app() {
     FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, draw_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, draw_callback, game_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     Gui* gui = furi_record_open(RECORD_GUI);
@@ -408,7 +410,7 @@ int32_t game_2048_app() {
             // handle only press event, ignore repeat/release events
             if(input.type != InputTypePress) continue;
 
-            GameState* game_state = (GameState*)acquire_mutex_block(&state_mutex);
+            furi_mutex_acquire(game_state->mutex, FuriWaitForever);
 
             switch(game_state->state) {
             case GameStateMenu:
@@ -493,7 +495,7 @@ int32_t game_2048_app() {
             }
 
             view_port_update(view_port);
-            release_mutex(&state_mutex, game_state);
+            furi_mutex_release(game_state->mutex);
         }
     }
 
@@ -504,7 +506,7 @@ int32_t game_2048_app() {
 
     furi_message_queue_free(event_queue);
 
-    delete_mutex(&state_mutex);
+    furi_mutex_free(game_state->mutex);
 
     free(game_state);
     free(move_result);
diff --git a/applications/plugins/gps_nmea_uart/gps.c b/applications/plugins/gps_nmea_uart/gps.c
index 62053cedea..b36fd080ba 100644
--- a/applications/plugins/gps_nmea_uart/gps.c
+++ b/applications/plugins/gps_nmea_uart/gps.c
@@ -15,10 +15,9 @@ typedef struct {
 } PluginEvent;
 
 static void render_callback(Canvas* const canvas, void* context) {
-    const GpsUart* gps_uart = acquire_mutex((ValueMutex*)context, 25);
-    if(gps_uart == NULL) {
-        return;
-    }
+    furi_assert(context);
+    const GpsUart* gps_uart = context;
+    furi_mutex_acquire(gps_uart->mutex, FuriWaitForever);
 
     canvas_set_font(canvas, FontPrimary);
     canvas_draw_str_aligned(canvas, 32, 8, AlignCenter, AlignBottom, "Latitude");
@@ -57,7 +56,7 @@ static void render_callback(Canvas* const canvas, void* context) {
         gps_uart->status.time_seconds);
     canvas_draw_str_aligned(canvas, 96, 62, AlignCenter, AlignBottom, buffer);
 
-    release_mutex((ValueMutex*)context, gps_uart);
+    furi_mutex_release(gps_uart->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -74,8 +73,8 @@ int32_t gps_app(void* p) {
 
     GpsUart* gps_uart = gps_uart_enable();
 
-    ValueMutex gps_uart_mutex;
-    if(!init_mutex(&gps_uart_mutex, gps_uart, sizeof(GpsUart))) {
+    gps_uart->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!gps_uart->mutex) {
         FURI_LOG_E("GPS", "cannot create mutex\r\n");
         free(gps_uart);
         return 255;
@@ -83,18 +82,18 @@ int32_t gps_app(void* p) {
 
     // set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &gps_uart_mutex);
+    view_port_draw_callback_set(view_port, render_callback, gps_uart);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // open GUI and register view_port
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     PluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
-        GpsUart* gps_uart = (GpsUart*)acquire_mutex_block(&gps_uart_mutex);
+        furi_mutex_acquire(gps_uart->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -118,15 +117,15 @@ int32_t gps_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&gps_uart_mutex, gps_uart);
+        furi_mutex_release(gps_uart->mutex);
     }
 
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
-    furi_record_close("gui");
+    furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&gps_uart_mutex);
+    furi_mutex_free(gps_uart->mutex);
     gps_uart_disable(gps_uart);
 
     return 0;
diff --git a/applications/plugins/gps_nmea_uart/gps_uart.h b/applications/plugins/gps_nmea_uart/gps_uart.h
index d6aafae9f6..fd33eb2450 100644
--- a/applications/plugins/gps_nmea_uart/gps_uart.h
+++ b/applications/plugins/gps_nmea_uart/gps_uart.h
@@ -22,6 +22,7 @@ typedef struct {
 } GpsStatus;
 
 typedef struct {
+    FuriMutex* mutex;
     FuriThread* thread;
     FuriStreamBuffer* rx_stream;
     uint8_t rx_buf[RX_BUF_SIZE];
diff --git a/applications/plugins/hc_sr04/hc_sr04.c b/applications/plugins/hc_sr04/hc_sr04.c
index db075247a6..66ffdad307 100644
--- a/applications/plugins/hc_sr04/hc_sr04.c
+++ b/applications/plugins/hc_sr04/hc_sr04.c
@@ -24,6 +24,7 @@ typedef struct {
 } PluginEvent;
 
 typedef struct {
+    FuriMutex* mutex;
     NotificationApp* notification;
     bool have_5v;
     bool measurement_made;
@@ -41,10 +42,10 @@ const NotificationSequence sequence_done = {
 };
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(plugin_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
+
     // border around the edge of the screen
     // canvas_draw_frame(canvas, 0, 0, 128, 64);
 
@@ -85,7 +86,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         }
     }
 
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -184,8 +185,8 @@ int32_t hc_sr04_app() {
 
     furi_hal_console_disable();
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         FURI_LOG_E("hc_sr04", "cannot create mutex\r\n");
         if(furi_hal_power_is_otg_enabled()) {
             furi_hal_power_disable_otg();
@@ -201,7 +202,7 @@ int32_t hc_sr04_app() {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -212,7 +213,7 @@ int32_t hc_sr04_app() {
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
-        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -238,7 +239,7 @@ int32_t hc_sr04_app() {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
+        furi_mutex_release(plugin_state->mutex);
     }
 
     if(furi_hal_power_is_otg_enabled()) {
@@ -267,7 +268,8 @@ int32_t hc_sr04_app() {
     furi_record_close(RECORD_NOTIFICATION);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(plugin_state->mutex);
+    free(plugin_state);
 
     return 0;
 }
diff --git a/applications/plugins/heap_defence_game/heap_defence.c b/applications/plugins/heap_defence_game/heap_defence.c
index 2981d6c27e..378a428232 100644
--- a/applications/plugins/heap_defence_game/heap_defence.c
+++ b/applications/plugins/heap_defence_game/heap_defence.c
@@ -87,6 +87,7 @@ typedef struct {
     Person* person;
     Animations animation;
     GameStatuses game_status;
+    FuriMutex* mutex;
 } GameState;
 
 typedef Box** Field;
@@ -433,15 +434,15 @@ static void draw_box(Canvas* canvas, Box* box, int x, int y) {
 
 static void heap_defense_render_callback(Canvas* const canvas, void* mutex) {
     furi_assert(mutex);
-
-    const GameState* game = acquire_mutex((ValueMutex*)mutex, 25);
+    const GameState* game = mutex;
+    furi_mutex_acquire(game->mutex, FuriWaitForever);
 
     ///Draw GameOver or Pause
     if(!(game->game_status & GameStatusInProgress)) {
         FURI_LOG_W(TAG, "[DAED_DRAW]func: [%s] line: %d ", __FUNCTION__, __LINE__);
 
         canvas_draw_icon_animation(canvas, 0, 0, animations[game->animation]);
-        release_mutex((ValueMutex*)mutex, game);
+        furi_mutex_release(game->mutex);
         return;
     }
 
@@ -481,7 +482,7 @@ static void heap_defense_render_callback(Canvas* const canvas, void* mutex) {
         }
     }
 
-    release_mutex((ValueMutex*)mutex, game);
+    furi_mutex_release(game->mutex);
 }
 
 static void heap_defense_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -506,25 +507,25 @@ int32_t heap_defence_app(void* p) {
     FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(GameEvent));
     GameState* game = allocGameState();
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, game, sizeof(GameState))) {
+    game->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!game->mutex) {
         game_destroy(game);
         return 1;
     }
 
     assets_load();
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, heap_defense_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, heap_defense_render_callback, game);
     view_port_input_callback_set(view_port, heap_defense_input_callback, event_queue);
 
     FuriTimer* timer =
         furi_timer_alloc(heap_defense_timer_callback, FuriTimerTypePeriodic, event_queue);
     furi_timer_start(timer, furi_kernel_get_tick_frequency() / TIMER_UPDATE_FREQ);
 
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
-    NotificationApp* notification = furi_record_open("notification");
+    NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
 
     memset(game->field[Y_LAST], 128, ROW_BYTE_SIZE);
     game->person->p.y -= 2;
@@ -540,7 +541,7 @@ int32_t heap_defence_app(void* p) {
             continue;
         }
 
-        game = (GameState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(game->mutex, FuriWaitForever);
 
         //unset vibration
         if(game->game_status & GameStatusVibro) {
@@ -577,7 +578,7 @@ int32_t heap_defence_app(void* p) {
                 notification_message(notification, &sequence_error);
             }
         }
-        release_mutex(&state_mutex, game);
+        furi_mutex_release(game->mutex);
         view_port_update(view_port);
     }
 
@@ -585,11 +586,11 @@ int32_t heap_defence_app(void* p) {
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
     view_port_free(view_port);
-    furi_record_close("gui");
-    furi_record_close("notification");
+    furi_record_close(RECORD_GUI);
+    furi_record_close(RECORD_NOTIFICATION);
     furi_message_queue_free(event_queue);
     assets_clear();
-    delete_mutex(&state_mutex);
+    furi_mutex_free(game->mutex);
     game_destroy(game);
 
     return 0;
diff --git a/applications/plugins/hid_app/hid.c b/applications/plugins/hid_app/hid.c
index 7f63f0cc6e..949ff63b3e 100644
--- a/applications/plugins/hid_app/hid.c
+++ b/applications/plugins/hid_app/hid.c
@@ -376,7 +376,17 @@ int32_t hid_ble_app(void* p) {
     // Wait 2nd core to update nvm storage
     furi_delay_ms(200);
 
-    bt_keys_storage_set_storage_path(app->bt, HID_BT_KEYS_STORAGE_PATH);
+    // Migrate data from old sd-card folder
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    storage_common_migrate(
+        storage,
+        EXT_PATH("apps/Tools/" HID_BT_KEYS_STORAGE_NAME),
+        APP_DATA_PATH(HID_BT_KEYS_STORAGE_NAME));
+
+    bt_keys_storage_set_storage_path(app->bt, APP_DATA_PATH(HID_BT_KEYS_STORAGE_NAME));
+
+    furi_record_close(RECORD_STORAGE);
 
     if(!bt_set_profile(app->bt, BtProfileHidKeyboard)) {
         FURI_LOG_E(TAG, "Failed to switch to HID profile");
diff --git a/applications/plugins/hid_app/hid.h b/applications/plugins/hid_app/hid.h
index fe32a199b4..8ed1664a34 100644
--- a/applications/plugins/hid_app/hid.h
+++ b/applications/plugins/hid_app/hid.h
@@ -23,7 +23,7 @@
 #include "views/hid_mouse_jiggler.h"
 #include "views/hid_tiktok.h"
 
-#define HID_BT_KEYS_STORAGE_PATH EXT_PATH("apps/Tools/.bt_hid.keys")
+#define HID_BT_KEYS_STORAGE_NAME ".bt_hid.keys"
 
 typedef enum {
     HidTransportUsb,
diff --git a/applications/plugins/ibtn_fuzzer/ibtnfuzzer.c b/applications/plugins/ibtn_fuzzer/ibtnfuzzer.c
index f02da3b828..c5f2a5f7c5 100644
--- a/applications/plugins/ibtn_fuzzer/ibtnfuzzer.c
+++ b/applications/plugins/ibtn_fuzzer/ibtnfuzzer.c
@@ -9,11 +9,9 @@
 #define IBTNFUZZER_APP_FOLDER "/ext/ibtnfuzzer"
 
 static void ibtnfuzzer_draw_callback(Canvas* const canvas, void* ctx) {
-    iBtnFuzzerState* ibtnfuzzer_state = (iBtnFuzzerState*)acquire_mutex((ValueMutex*)ctx, 100);
-
-    if(ibtnfuzzer_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    iBtnFuzzerState* ibtnfuzzer_state = ctx;
+    furi_mutex_acquire(ibtnfuzzer_state->mutex, FuriWaitForever);
 
     // Draw correct Canvas
     switch(ibtnfuzzer_state->current_scene) {
@@ -35,7 +33,7 @@ static void ibtnfuzzer_draw_callback(Canvas* const canvas, void* ctx) {
         break;
     }
 
-    release_mutex((ValueMutex*)ctx, ibtnfuzzer_state);
+    furi_mutex_release(ibtnfuzzer_state->mutex);
 }
 
 void ibtnfuzzer_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -120,11 +118,9 @@ int32_t ibtnfuzzer_start(void* p) {
     FURI_LOG_I(TAG, "Initializing input");
     FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(iBtnFuzzerEvent));
     iBtnFuzzerState* ibtnfuzzer_state = ibtnfuzzer_alloc();
-    ValueMutex ibtnfuzzer_state_mutex;
 
-    // Mutex
-    FURI_LOG_I(TAG, "Initializing ibtnfuzzer mutex");
-    if(!init_mutex(&ibtnfuzzer_state_mutex, ibtnfuzzer_state, sizeof(iBtnFuzzerState))) {
+    ibtnfuzzer_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!ibtnfuzzer_state->mutex) {
         FURI_LOG_E(TAG, "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         furi_record_close(RECORD_NOTIFICATION);
@@ -141,7 +137,7 @@ int32_t ibtnfuzzer_start(void* p) {
     // Configure view port
     FURI_LOG_I(TAG, "Initializing viewport");
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, ibtnfuzzer_draw_callback, &ibtnfuzzer_state_mutex);
+    view_port_draw_callback_set(view_port, ibtnfuzzer_draw_callback, ibtnfuzzer_state);
     view_port_input_callback_set(view_port, ibtnfuzzer_input_callback, event_queue);
 
     // Configure timer
@@ -160,6 +156,7 @@ int32_t ibtnfuzzer_start(void* p) {
     while(ibtnfuzzer_state->is_running) {
         // Get next event
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 25);
+        //furi_mutex_acquire(ibtnfuzzer_state->mutex, FuriWaitForever);
         if(event_status == FuriStatusOk) {
             if(event.evt_type == EventTypeKey) {
                 //Handle event key
@@ -250,6 +247,7 @@ int32_t ibtnfuzzer_start(void* p) {
                 view_port_update(view_port);
             }
         }
+        //furi_mutex_release(ibtnfuzzer_state->mutex);
     }
 
     // Cleanup
@@ -262,6 +260,7 @@ int32_t ibtnfuzzer_start(void* p) {
     furi_message_queue_free(event_queue);
     furi_record_close(RECORD_GUI);
     furi_record_close(RECORD_NOTIFICATION);
+    furi_mutex_free(ibtnfuzzer_state->mutex);
     ibtnfuzzer_free(ibtnfuzzer_state);
 
     return 0;
diff --git a/applications/plugins/ibtn_fuzzer/ibtnfuzzer.h b/applications/plugins/ibtn_fuzzer/ibtnfuzzer.h
index 35ce89b172..91a9c6b0ce 100644
--- a/applications/plugins/ibtn_fuzzer/ibtnfuzzer.h
+++ b/applications/plugins/ibtn_fuzzer/ibtnfuzzer.h
@@ -56,6 +56,7 @@ typedef struct {
 
 // STRUCTS
 typedef struct {
+    FuriMutex* mutex;
     bool is_running;
     bool is_attacking;
     iBtnFuzzerScene current_scene;
@@ -78,7 +79,8 @@ typedef struct {
     uint8_t key_index;
     iButtonWorker* worker;
     iButtonKey* key;
-    iButtonKeyType keytype;
+    iButtonProtocolId keytype;
+    iButtonProtocols* protocols;
     bool workr_rund;
     bool enter_rerun;
     bool attack_stop_called;
diff --git a/applications/plugins/ibtn_fuzzer/scene/ibtnfuzzer_scene_run_attack.c b/applications/plugins/ibtn_fuzzer/scene/ibtnfuzzer_scene_run_attack.c
index e45035d6b2..1cab8b04ea 100644
--- a/applications/plugins/ibtn_fuzzer/scene/ibtnfuzzer_scene_run_attack.c
+++ b/applications/plugins/ibtn_fuzzer/scene/ibtnfuzzer_scene_run_attack.c
@@ -72,14 +72,15 @@ void ibtnfuzzer_scene_run_attack_on_enter(iBtnFuzzerState* context) {
     context->time_between_cards = 8;
     context->attack_step = 0;
     context->attack_stop_called = false;
-    context->key = ibutton_key_alloc();
-    context->worker = ibutton_worker_alloc();
+    context->protocols = ibutton_protocols_alloc();
+    context->key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(context->protocols));
+    context->worker = ibutton_worker_alloc(context->protocols);
     if(context->proto == Metakom) {
-        context->keytype = iButtonKeyMetakom;
+        context->keytype = ibutton_protocols_get_id_by_name(context->protocols, "Metakom");
     } else if(context->proto == Cyfral) {
-        context->keytype = iButtonKeyCyfral;
+        context->keytype = ibutton_protocols_get_id_by_name(context->protocols, "Cyfral");
     } else {
-        context->keytype = iButtonKeyDS1990;
+        context->keytype = ibutton_protocols_get_id_by_name(context->protocols, "DS1990");
     }
     context->workr_rund = false;
 }
@@ -90,8 +91,9 @@ void ibtnfuzzer_scene_run_attack_on_exit(iBtnFuzzerState* context) {
         ibutton_worker_stop_thread(context->worker);
         context->workr_rund = false;
     }
-    ibutton_worker_free(context->worker);
     ibutton_key_free(context->key);
+    ibutton_worker_free(context->worker);
+    ibutton_protocols_free(context->protocols);
     notification_message(context->notify, &sequence_blink_stop);
 }
 
@@ -99,9 +101,14 @@ void ibtnfuzzer_scene_run_attack_on_tick(iBtnFuzzerState* context) {
     if(context->is_attacking) {
         if(1 == counter) {
             ibutton_worker_start_thread(context->worker);
-            ibutton_key_set_type(context->key, context->keytype);
-            ibutton_key_set_data(
-                context->key, context->payload, ibutton_key_get_size_by_type(context->keytype));
+            ibutton_key_set_protocol_id(context->key, context->keytype);
+            iButtonEditableData data;
+            ibutton_protocols_get_editable_data(context->protocols, context->key, &data);
+            data.size = sizeof(context->payload);
+            for(size_t i = 0; i < data.size; i++) {
+                data.ptr[i] = context->payload[i];
+            }
+
             ibutton_worker_emulate_start(context->worker, context->key);
             context->workr_rund = true;
         } else if(0 == counter) {
diff --git a/applications/plugins/metronome/metronome.c b/applications/plugins/metronome/metronome.c
index 06bce1bff5..a01f4418d2 100644
--- a/applications/plugins/metronome/metronome.c
+++ b/applications/plugins/metronome/metronome.c
@@ -1,7 +1,6 @@
 #include <furi.h>
 #include <furi_hal.h>
 #include <input/input.h>
-#include <m-string.h>
 #include <stdlib.h>
 
 #include <gui/gui.h>
@@ -50,31 +49,33 @@ typedef struct {
     enum OutputMode output_mode;
     FuriTimer* timer;
     NotificationApp* notifications;
+    FuriMutex* mutex;
 } MetronomeState;
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const MetronomeState* metronome_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(metronome_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const MetronomeState* metronome_state = ctx;
+    furi_mutex_acquire(metronome_state->mutex, FuriWaitForever);
 
-    string_t tempStr;
-    string_init(tempStr);
+    FuriString* tempStr = furi_string_alloc();
 
     canvas_draw_frame(canvas, 0, 0, 128, 64);
 
     canvas_set_font(canvas, FontPrimary);
 
     // draw bars/beat
-    string_printf(tempStr, "%d/%d", metronome_state->beats_per_bar, metronome_state->note_length);
-    canvas_draw_str_aligned(canvas, 64, 8, AlignCenter, AlignCenter, string_get_cstr(tempStr));
-    string_reset(tempStr);
+    furi_string_printf(
+        tempStr, "%d/%d", metronome_state->beats_per_bar, metronome_state->note_length);
+    canvas_draw_str_aligned(
+        canvas, 64, 8, AlignCenter, AlignCenter, furi_string_get_cstr(tempStr));
+    furi_string_reset(tempStr);
 
     // draw BPM value
-    string_printf(tempStr, "%.2f", metronome_state->bpm);
+    furi_string_printf(tempStr, "%.2f", metronome_state->bpm);
     canvas_set_font(canvas, FontBigNumbers);
-    canvas_draw_str_aligned(canvas, 64, 24, AlignCenter, AlignCenter, string_get_cstr(tempStr));
-    string_reset(tempStr);
+    canvas_draw_str_aligned(
+        canvas, 64, 24, AlignCenter, AlignCenter, furi_string_get_cstr(tempStr));
+    furi_string_reset(tempStr);
 
     // draw volume indicator
     // always draw first waves
@@ -126,8 +127,8 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         canvas, 8, 36, 112, (float)metronome_state->current_beat / metronome_state->beats_per_bar);
 
     // cleanup
-    string_clear(tempStr);
-    release_mutex((ValueMutex*)ctx, metronome_state);
+    furi_string_free(tempStr);
+    furi_mutex_release(metronome_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -139,7 +140,10 @@ static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queu
 
 static void timer_callback(void* ctx) {
     // this is where we go BEEP!
-    MetronomeState* metronome_state = acquire_mutex((ValueMutex*)ctx, 25);
+    furi_assert(ctx);
+    MetronomeState* metronome_state = ctx;
+    furi_mutex_acquire(metronome_state->mutex, FuriWaitForever);
+
     metronome_state->current_beat++;
     if(metronome_state->current_beat > metronome_state->beats_per_bar) {
         metronome_state->current_beat = 1;
@@ -200,7 +204,7 @@ static void timer_callback(void* ctx) {
     }
     notification_message(metronome_state->notifications, &sequence_reset_rgb);
 
-    release_mutex((ValueMutex*)ctx, metronome_state);
+    furi_mutex_release(metronome_state->mutex);
 }
 
 static uint32_t state_to_sleep_ticks(MetronomeState* metronome_state) {
@@ -273,8 +277,8 @@ int32_t metronome_app() {
     MetronomeState* metronome_state = malloc(sizeof(MetronomeState));
     metronome_state_init(metronome_state);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, metronome_state, sizeof(MetronomeState))) {
+    metronome_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!metronome_state->mutex) {
         FURI_LOG_E("Metronome", "cannot create mutex\r\n");
         free(metronome_state);
         return 255;
@@ -282,19 +286,20 @@ int32_t metronome_app() {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, metronome_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
-    metronome_state->timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, &state_mutex);
+    metronome_state->timer =
+        furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, metronome_state);
 
     // Open GUI and register view_port
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     PluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
-        MetronomeState* metronome_state = (MetronomeState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(metronome_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             if(event.type == EventTypeKey) {
@@ -373,21 +378,18 @@ int32_t metronome_app() {
                     }
                 }
             }
-        } else {
-            FURI_LOG_D("Metronome", "FuriMessageQueue: event timeout");
-            // event timeout
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, metronome_state);
+        furi_mutex_release(metronome_state->mutex);
     }
 
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
-    furi_record_close("gui");
+    furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(metronome_state->mutex);
     furi_timer_free(metronome_state->timer);
     furi_record_close(RECORD_NOTIFICATION);
     free(metronome_state);
diff --git a/applications/plugins/minesweeper/minesweeper.c b/applications/plugins/minesweeper/minesweeper.c
index d5e2e715dc..2adca65e9d 100644
--- a/applications/plugins/minesweeper/minesweeper.c
+++ b/applications/plugins/minesweeper/minesweeper.c
@@ -57,6 +57,7 @@ typedef struct {
     int flags_set;
     bool game_started;
     uint32_t game_started_tick;
+    FuriMutex* mutex;
 } Minesweeper;
 
 static void timer_callback(void* ctx) {
@@ -74,10 +75,10 @@ static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queu
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const Minesweeper* minesweeper_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(minesweeper_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const Minesweeper* minesweeper_state = ctx;
+    furi_mutex_acquire(minesweeper_state->mutex, FuriWaitForever);
+
     FuriString* mineStr;
     FuriString* timeStr;
     mineStr = furi_string_alloc();
@@ -162,7 +163,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
 
     furi_string_free(mineStr);
     furi_string_free(timeStr);
-    release_mutex((ValueMutex*)ctx, minesweeper_state);
+    furi_mutex_release(minesweeper_state->mutex);
 }
 
 static void setup_playfield(Minesweeper* minesweeper_state) {
@@ -396,8 +397,8 @@ int32_t minesweeper_app(void* p) {
     // setup
     minesweeper_state_init(minesweeper_state);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, minesweeper_state, sizeof(minesweeper_state))) {
+    minesweeper_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!minesweeper_state->mutex) {
         FURI_LOG_E("Minesweeper", "cannot create mutex\r\n");
         free(minesweeper_state);
         return 255;
@@ -406,12 +407,13 @@ int32_t minesweeper_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, minesweeper_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
-    minesweeper_state->timer = furi_timer_alloc(timer_callback, FuriTimerTypeOnce, &state_mutex);
+    minesweeper_state->timer =
+        furi_timer_alloc(timer_callback, FuriTimerTypeOnce, minesweeper_state);
 
     // Open GUI and register view_port
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     // Call dolphin deed on game start
@@ -420,7 +422,7 @@ int32_t minesweeper_app(void* p) {
     PluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        Minesweeper* minesweeper_state = (Minesweeper*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(minesweeper_state->mutex, FuriWaitForever);
         if(event_status == FuriStatusOk) {
             // press events
             if(event.type == EventTypeKey) {
@@ -508,19 +510,16 @@ int32_t minesweeper_app(void* p) {
                     }
                 }
             }
-        } else {
-            // event timeout
-            ;
         }
         view_port_update(view_port);
-        release_mutex(&state_mutex, minesweeper_state);
+        furi_mutex_release(minesweeper_state->mutex);
     }
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
-    furi_record_close("gui");
+    furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(minesweeper_state->mutex);
     furi_timer_free(minesweeper_state->timer);
     free(minesweeper_state);
 
diff --git a/applications/plugins/mousejacker/mousejacker.c b/applications/plugins/mousejacker/mousejacker.c
index 3b1b2e6f72..606e092ca4 100644
--- a/applications/plugins/mousejacker/mousejacker.c
+++ b/applications/plugins/mousejacker/mousejacker.c
@@ -40,10 +40,10 @@ char target_address_str[12] = "None";
 char target_text[30];
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(plugin_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
+
     // border around the edge of the screen
     canvas_draw_frame(canvas, 0, 0, 128, 64);
 
@@ -82,7 +82,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         canvas_draw_str_aligned(canvas, 3, 30, AlignLeft, AlignBottom, "to exit");
     }
 
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -289,8 +289,8 @@ int32_t mousejacker_app(void* p) {
 
     PluginState* plugin_state = malloc(sizeof(PluginState));
     mousejacker_state_init(plugin_state);
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         FURI_LOG_E("mousejacker", "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(plugin_state);
@@ -299,7 +299,7 @@ int32_t mousejacker_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -330,7 +330,7 @@ int32_t mousejacker_app(void* p) {
     PluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -380,7 +380,7 @@ int32_t mousejacker_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
+        furi_mutex_release(plugin_state->mutex);
     }
 
     furi_thread_free(plugin_state->mjthread);
@@ -391,6 +391,7 @@ int32_t mousejacker_app(void* p) {
     furi_record_close(RECORD_STORAGE);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
+    furi_mutex_free(plugin_state->mutex);
     free(plugin_state);
 
     return 0;
diff --git a/applications/plugins/mousejacker/mousejacker_ducky.h b/applications/plugins/mousejacker/mousejacker_ducky.h
index b4922ed38b..e1a422ea74 100644
--- a/applications/plugins/mousejacker/mousejacker_ducky.h
+++ b/applications/plugins/mousejacker/mousejacker_ducky.h
@@ -21,6 +21,7 @@ typedef struct {
 } MJDuckyKey;
 
 typedef struct {
+    FuriMutex* mutex;
     bool ducky_err;
     bool addr_err;
     bool is_thread_running;
diff --git a/applications/plugins/multi_converter/multi_converter.c b/applications/plugins/multi_converter/multi_converter.c
index 5907303575..bd2b62587f 100644
--- a/applications/plugins/multi_converter/multi_converter.c
+++ b/applications/plugins/multi_converter/multi_converter.c
@@ -8,10 +8,9 @@
 #include "multi_converter_mode_select.h"
 
 static void multi_converter_render_callback(Canvas* const canvas, void* ctx) {
-    const MultiConverterState* multi_converter_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(multi_converter_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const MultiConverterState* multi_converter_state = ctx;
+    furi_mutex_acquire(multi_converter_state->mutex, FuriWaitForever);
 
     if(multi_converter_state->mode == ModeDisplay) {
         multi_converter_mode_display_draw(canvas, multi_converter_state);
@@ -19,7 +18,7 @@ static void multi_converter_render_callback(Canvas* const canvas, void* ctx) {
         multi_converter_mode_select_draw(canvas, multi_converter_state);
     }
 
-    release_mutex((ValueMutex*)ctx, multi_converter_state);
+    furi_mutex_release(multi_converter_state->mutex);
 }
 
 static void
@@ -62,8 +61,8 @@ int32_t multi_converter_app(void* p) {
     MultiConverterState* multi_converter_state = malloc(sizeof(MultiConverterState));
 
     // set mutex for plugin state (different threads can access it)
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, multi_converter_state, sizeof(multi_converter_state))) {
+    multi_converter_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!multi_converter_state->mutex) {
         FURI_LOG_E("MultiConverter", "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(multi_converter_state);
@@ -72,11 +71,11 @@ int32_t multi_converter_app(void* p) {
 
     // register callbacks for drawing and input processing
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, multi_converter_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, multi_converter_render_callback, multi_converter_state);
     view_port_input_callback_set(view_port, multi_converter_input_callback, event_queue);
 
     // open GUI and register view_port
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     multi_converter_init(multi_converter_state);
@@ -85,8 +84,7 @@ int32_t multi_converter_app(void* p) {
     MultiConverterEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        MultiConverterState* multi_converter_state =
-            (MultiConverterState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(multi_converter_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -148,20 +146,18 @@ int32_t multi_converter_app(void* p) {
             } else if(multi_converter_state->keyboard_lock) {
                 multi_converter_state->keyboard_lock = 0;
             }
-        } else {
-            // event timeout
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, multi_converter_state);
+        furi_mutex_release(multi_converter_state->mutex);
     }
 
     view_port_enabled_set(view_port, false);
     gui_remove_view_port(gui, view_port);
-    furi_record_close("gui");
+    furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(multi_converter_state->mutex);
     free(multi_converter_state);
 
     return 0;
diff --git a/applications/plugins/multi_converter/multi_converter_definitions.h b/applications/plugins/multi_converter/multi_converter_definitions.h
index 3bed192a09..2f79bc7d9d 100644
--- a/applications/plugins/multi_converter/multi_converter_definitions.h
+++ b/applications/plugins/multi_converter/multi_converter_definitions.h
@@ -70,6 +70,7 @@ struct MultiConverterUnit {
 };
 
 struct MultiConverterState {
+    FuriMutex* mutex;
     char buffer_orig[MULTI_CONVERTER_NUMBER_DIGITS + 1];
     char buffer_dest[MULTI_CONVERTER_NUMBER_DIGITS + 1];
     MultiConverterUnitType unit_type_orig;
diff --git a/applications/plugins/nfc_magic/nfc_magic_worker.c b/applications/plugins/nfc_magic/nfc_magic_worker.c
index 523c794f7d..32202f12d1 100644
--- a/applications/plugins/nfc_magic/nfc_magic_worker.c
+++ b/applications/plugins/nfc_magic/nfc_magic_worker.c
@@ -49,6 +49,9 @@ void nfc_magic_worker_start(
     furi_assert(nfc_magic_worker);
     furi_assert(dev_data);
 
+    furi_hal_nfc_deinit();
+    furi_hal_nfc_init();
+
     nfc_magic_worker->callback = callback;
     nfc_magic_worker->context = context;
     nfc_magic_worker->dev_data = dev_data;
diff --git a/applications/plugins/nfc_magic/scenes/nfc_magic_scene_file_select.c b/applications/plugins/nfc_magic/scenes/nfc_magic_scene_file_select.c
index a19237ed47..d78422eeb6 100644
--- a/applications/plugins/nfc_magic/scenes/nfc_magic_scene_file_select.c
+++ b/applications/plugins/nfc_magic/scenes/nfc_magic_scene_file_select.c
@@ -11,6 +11,10 @@ void nfc_magic_scene_file_select_on_enter(void* context) {
     // Process file_select return
     nfc_device_set_loading_callback(nfc_magic->nfc_dev, nfc_magic_show_loading_popup, nfc_magic);
 
+    if(!furi_string_size(nfc_magic->nfc_dev->load_path)) {
+        furi_string_set_str(nfc_magic->nfc_dev->load_path, NFC_APP_FOLDER);
+    }
+
     if(nfc_file_select(nfc_magic->nfc_dev)) {
         if(nfc_magic_scene_file_select_is_file_suitable(nfc_magic->nfc_dev)) {
             scene_manager_next_scene(nfc_magic->scene_manager, NfcMagicSceneWriteConfirm);
diff --git a/applications/plugins/nrfsniff/nrfsniff.c b/applications/plugins/nrfsniff/nrfsniff.c
index 094775426f..56bc33d05a 100644
--- a/applications/plugins/nrfsniff/nrfsniff.c
+++ b/applications/plugins/nrfsniff/nrfsniff.c
@@ -29,8 +29,7 @@ typedef struct {
 } PluginEvent;
 
 typedef struct {
-    int x;
-    int y;
+    FuriMutex* mutex;
 } PluginState;
 
 char rate_text_fmt[] = "Transfer rate: %dMbps";
@@ -96,13 +95,13 @@ static void insert_addr(uint8_t* addr, uint8_t addr_size) {
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
+    furi_assert(ctx);
+    const PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
+
     uint8_t rate = 2;
     char sniffing[] = "Yes";
 
-    const PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(plugin_state == NULL) {
-        return;
-    }
     // border around the edge of the screen
     canvas_draw_frame(canvas, 0, 0, 128, 64);
     canvas_set_font(canvas, FontSecondary);
@@ -126,7 +125,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
     canvas_draw_str_aligned(canvas, 30, 50, AlignLeft, AlignBottom, addresses_header_text);
     canvas_draw_str_aligned(canvas, 30, 60, AlignLeft, AlignBottom, sniffed_address);
 
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -320,8 +319,8 @@ int32_t nrfsniff_app(void* p) {
     hexlify(address, 5, top_address);
     FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
     PluginState* plugin_state = malloc(sizeof(PluginState));
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         furi_message_queue_free(event_queue);
         FURI_LOG_E(TAG, "cannot create mutex\r\n");
         free(plugin_state);
@@ -332,7 +331,7 @@ int32_t nrfsniff_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -347,7 +346,7 @@ int32_t nrfsniff_app(void* p) {
     PluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -435,7 +434,7 @@ int32_t nrfsniff_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
+        furi_mutex_release(plugin_state->mutex);
     }
 
     clear_cache();
@@ -450,6 +449,7 @@ int32_t nrfsniff_app(void* p) {
     furi_record_close(RECORD_STORAGE);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
+    furi_mutex_free(plugin_state->mutex);
     free(plugin_state);
 
     return 0;
diff --git a/applications/plugins/picopass/helpers/iclass_elite_dict.c b/applications/plugins/picopass/helpers/iclass_elite_dict.c
index 455eb23c17..e8c13dd1df 100644
--- a/applications/plugins/picopass/helpers/iclass_elite_dict.c
+++ b/applications/plugins/picopass/helpers/iclass_elite_dict.c
@@ -3,8 +3,8 @@
 #include <lib/toolbox/args.h>
 #include <lib/flipper_format/flipper_format.h>
 
-#define ICLASS_ELITE_DICT_FLIPPER_PATH EXT_PATH("picopass/assets/iclass_elite_dict.txt")
-#define ICLASS_ELITE_DICT_USER_PATH EXT_PATH("picopass/assets/iclass_elite_dict_user.txt")
+#define ICLASS_ELITE_DICT_FLIPPER_NAME APP_DATA_PATH("assets/iclass_elite_dict.txt")
+#define ICLASS_ELITE_DICT_USER_NAME APP_DATA_PATH("assets/iclass_elite_dict_user.txt")
 
 #define TAG "IclassEliteDict"
 
@@ -21,10 +21,10 @@ bool iclass_elite_dict_check_presence(IclassEliteDictType dict_type) {
 
     bool dict_present = false;
     if(dict_type == IclassEliteDictTypeFlipper) {
-        dict_present = storage_common_stat(storage, ICLASS_ELITE_DICT_FLIPPER_PATH, NULL) ==
-                       FSE_OK;
+        dict_present =
+            (storage_common_stat(storage, ICLASS_ELITE_DICT_FLIPPER_NAME, NULL) == FSE_OK);
     } else if(dict_type == IclassEliteDictTypeUser) {
-        dict_present = storage_common_stat(storage, ICLASS_ELITE_DICT_USER_PATH, NULL) == FSE_OK;
+        dict_present = (storage_common_stat(storage, ICLASS_ELITE_DICT_USER_NAME, NULL) == FSE_OK);
     }
 
     furi_record_close(RECORD_STORAGE);
@@ -36,27 +36,26 @@ IclassEliteDict* iclass_elite_dict_alloc(IclassEliteDictType dict_type) {
     IclassEliteDict* dict = malloc(sizeof(IclassEliteDict));
     Storage* storage = furi_record_open(RECORD_STORAGE);
     dict->stream = buffered_file_stream_alloc(storage);
-    furi_record_close(RECORD_STORAGE);
     FuriString* next_line = furi_string_alloc();
 
     bool dict_loaded = false;
     do {
         if(dict_type == IclassEliteDictTypeFlipper) {
             if(!buffered_file_stream_open(
-                   dict->stream, ICLASS_ELITE_DICT_FLIPPER_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
+                   dict->stream, ICLASS_ELITE_DICT_FLIPPER_NAME, FSAM_READ, FSOM_OPEN_EXISTING)) {
                 buffered_file_stream_close(dict->stream);
                 break;
             }
         } else if(dict_type == IclassEliteDictTypeUser) {
             if(!buffered_file_stream_open(
-                   dict->stream, ICLASS_ELITE_DICT_USER_PATH, FSAM_READ_WRITE, FSOM_OPEN_ALWAYS)) {
+                   dict->stream, ICLASS_ELITE_DICT_USER_NAME, FSAM_READ_WRITE, FSOM_OPEN_ALWAYS)) {
                 buffered_file_stream_close(dict->stream);
                 break;
             }
         }
 
         // Read total amount of keys
-        while(true) {
+        while(true) { //-V547
             if(!stream_read_line(dict->stream, next_line)) break;
             if(furi_string_get_char(next_line, 0) == '#') continue;
             if(furi_string_size(next_line) != ICLASS_ELITE_KEY_LINE_LEN) continue;
@@ -69,12 +68,13 @@ IclassEliteDict* iclass_elite_dict_alloc(IclassEliteDictType dict_type) {
         FURI_LOG_I(TAG, "Loaded dictionary with %lu keys", dict->total_keys);
     } while(false);
 
-    if(!dict_loaded) {
+    if(!dict_loaded) { //-V547
         buffered_file_stream_close(dict->stream);
         free(dict);
         dict = NULL;
     }
 
+    furi_record_close(RECORD_STORAGE);
     furi_string_free(next_line);
 
     return dict;
diff --git a/applications/plugins/picopass/picopass.c b/applications/plugins/picopass/picopass.c
index bedaf38ef1..c1428b2fbc 100644
--- a/applications/plugins/picopass/picopass.c
+++ b/applications/plugins/picopass/picopass.c
@@ -171,6 +171,12 @@ void picopass_show_loading_popup(void* context, bool show) {
     }
 }
 
+static void picopass_migrate_from_old_folder() {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    storage_common_migrate(storage, "/ext/picopass", STORAGE_APP_DATA_PATH_PREFIX);
+    furi_record_close(RECORD_STORAGE);
+}
+
 bool picopass_is_memset(const uint8_t* data, const uint8_t pattern, size_t size) {
     bool result = size > 0;
     while(size > 0) {
@@ -183,6 +189,8 @@ bool picopass_is_memset(const uint8_t* data, const uint8_t pattern, size_t size)
 
 int32_t picopass_app(void* p) {
     UNUSED(p);
+    picopass_migrate_from_old_folder();
+
     Picopass* picopass = picopass_alloc();
 
     scene_manager_next_scene(picopass->scene_manager, PicopassSceneStart);
diff --git a/applications/plugins/picopass/picopass_device.c b/applications/plugins/picopass/picopass_device.c
index a5414b92b0..b5ba8ba78b 100644
--- a/applications/plugins/picopass/picopass_device.c
+++ b/applications/plugins/picopass/picopass_device.c
@@ -48,13 +48,9 @@ static bool picopass_device_save_file(
         if(use_load_path && !furi_string_empty(dev->load_path)) {
             // Get directory name
             path_extract_dirname(furi_string_get_cstr(dev->load_path), temp_str);
-            // Create picopass directory if necessary
-            if(!storage_simply_mkdir(dev->storage, furi_string_get_cstr(temp_str))) break;
             // Make path to file to save
             furi_string_cat_printf(temp_str, "/%s%s", dev_name, extension);
         } else {
-            // Create picopass directory if necessary
-            if(!storage_simply_mkdir(dev->storage, PICOPASS_APP_FOLDER)) break;
             // First remove picopass device file if it was saved
             furi_string_printf(temp_str, "%s/%s%s", folder, dev_name, extension);
         }
@@ -126,10 +122,11 @@ static bool picopass_device_save_file(
 bool picopass_device_save(PicopassDevice* dev, const char* dev_name) {
     if(dev->format == PicopassDeviceSaveFormatHF) {
         return picopass_device_save_file(
-            dev, dev_name, PICOPASS_APP_FOLDER, PICOPASS_APP_EXTENSION, true);
+            dev, dev_name, STORAGE_APP_DATA_PATH_PREFIX, PICOPASS_APP_EXTENSION, true);
     } else if(dev->format == PicopassDeviceSaveFormatLF) {
         return picopass_device_save_file(dev, dev_name, ANY_PATH("lfrfid"), ".rfid", true);
     }
+
     return false;
 }
 
@@ -170,6 +167,8 @@ static bool picopass_device_load_data(PicopassDevice* dev, FuriString* path, boo
         }
 
         size_t app_limit = AA1[PICOPASS_CONFIG_BLOCK_INDEX].data[0];
+        // Fix for unpersonalized cards that have app_limit set to 0xFF
+        if(app_limit > PICOPASS_MAX_APP_LIMIT) app_limit = PICOPASS_MAX_APP_LIMIT;
         for(size_t i = 6; i < app_limit; i++) {
             furi_string_printf(temp_str, "Block %d", i);
             if(!flipper_format_read_hex(
@@ -225,13 +224,12 @@ void picopass_device_free(PicopassDevice* picopass_dev) {
 bool picopass_file_select(PicopassDevice* dev) {
     furi_assert(dev);
 
-    // Input events and views are managed by file_browser
     FuriString* picopass_app_folder;
-    picopass_app_folder = furi_string_alloc_set(PICOPASS_APP_FOLDER);
+    picopass_app_folder = furi_string_alloc_set(STORAGE_APP_DATA_PATH_PREFIX);
 
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, PICOPASS_APP_EXTENSION, &I_Nfc_10px);
-    browser_options.base_path = PICOPASS_APP_FOLDER;
+    browser_options.base_path = STORAGE_APP_DATA_PATH_PREFIX;
 
     bool res = dialog_file_browser_show(
         dev->dialogs, dev->load_path, picopass_app_folder, &browser_options);
@@ -274,7 +272,7 @@ bool picopass_device_delete(PicopassDevice* dev, bool use_load_path) {
             furi_string_set(file_path, dev->load_path);
         } else {
             furi_string_printf(
-                file_path, "%s/%s%s", PICOPASS_APP_FOLDER, dev->dev_name, PICOPASS_APP_EXTENSION);
+                file_path, APP_DATA_PATH("%s%s"), dev->dev_name, PICOPASS_APP_EXTENSION);
         }
         if(!storage_simply_remove(dev->storage, furi_string_get_cstr(file_path))) break;
         deleted = true;
diff --git a/applications/plugins/picopass/picopass_device.h b/applications/plugins/picopass/picopass_device.h
index 99f1ceea64..d7d0977df4 100644
--- a/applications/plugins/picopass/picopass_device.h
+++ b/applications/plugins/picopass/picopass_device.h
@@ -24,7 +24,6 @@
 #define PICOPASS_AIA_BLOCK_INDEX 5
 #define PICOPASS_PACS_CFG_BLOCK_INDEX 6
 
-#define PICOPASS_APP_FOLDER ANY_PATH("picopass")
 #define PICOPASS_APP_EXTENSION ".picopass"
 #define PICOPASS_APP_SHADOW_EXTENSION ".pas"
 
@@ -81,7 +80,6 @@ typedef struct {
     PicopassDeviceSaveFormat format;
     PicopassLoadingCallback loading_cb;
     void* loading_cb_ctx;
-
 } PicopassDevice;
 
 PicopassDevice* picopass_device_alloc();
diff --git a/applications/plugins/picopass/picopass_keys.c b/applications/plugins/picopass/picopass_keys.c
new file mode 100644
index 0000000000..43dfc63126
--- /dev/null
+++ b/applications/plugins/picopass/picopass_keys.c
@@ -0,0 +1,8 @@
+#include "picopass_keys.h"
+
+const uint8_t picopass_iclass_key[] = {0xaf, 0xa7, 0x85, 0xa7, 0xda, 0xb3, 0x33, 0x78};
+const uint8_t picopass_factory_credit_key[] = {0x76, 0x65, 0x54, 0x43, 0x32, 0x21, 0x10, 0x00};
+const uint8_t picopass_factory_debit_key[] = {0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87};
+const uint8_t picopass_xice_key[] = {0x20, 0x20, 0x66, 0x66, 0x66, 0x66, 0x88, 0x88};
+const uint8_t picopass_xicl_key[] = {0x20, 0x20, 0x66, 0x66, 0x66, 0x66, 0x88, 0x88};
+const uint8_t picopass_xics_key[] = {0x66, 0x66, 0x20, 0x20, 0x66, 0x66, 0x88, 0x88};
diff --git a/applications/plugins/picopass/picopass_keys.h b/applications/plugins/picopass/picopass_keys.h
new file mode 100644
index 0000000000..2b5dba6610
--- /dev/null
+++ b/applications/plugins/picopass/picopass_keys.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "picopass_device.h"
+
+extern const uint8_t picopass_iclass_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_factory_credit_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_factory_debit_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_xice_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_xicl_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_xics_key[PICOPASS_BLOCK_LEN];
diff --git a/applications/plugins/picopass/picopass_worker.c b/applications/plugins/picopass/picopass_worker.c
index 441efb3395..d141bdf6bb 100644
--- a/applications/plugins/picopass/picopass_worker.c
+++ b/applications/plugins/picopass/picopass_worker.c
@@ -4,10 +4,6 @@
 
 #define TAG "PicopassWorker"
 
-const uint8_t picopass_iclass_key[] = {0xaf, 0xa7, 0x85, 0xa7, 0xda, 0xb3, 0x33, 0x78};
-const uint8_t picopass_factory_credit_key[] = {0x76, 0x65, 0x54, 0x43, 0x32, 0x21, 0x10, 0x00};
-const uint8_t picopass_factory_debit_key[] = {0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87};
-
 static void picopass_worker_enable_field() {
     furi_hal_nfc_ll_txrx_on();
     furi_hal_nfc_exit_sleep();
@@ -176,55 +172,12 @@ ReturnCode picopass_read_preauth(PicopassBlock* AA1) {
     return ERR_NONE;
 }
 
-static ReturnCode picopass_auth_standard(uint8_t* csn, uint8_t* div_key) {
-    rfalPicoPassReadCheckRes rcRes;
-    rfalPicoPassCheckRes chkRes;
-
-    ReturnCode err;
-
-    uint8_t mac[4] = {0};
-    uint8_t ccnr[12] = {0};
-
-    err = rfalPicoPassPollerReadCheck(&rcRes);
-    if(err != ERR_NONE) {
-        FURI_LOG_E(TAG, "rfalPicoPassPollerReadCheck error %d", err);
-        return err;
-    }
-    memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
-
-    loclass_diversifyKey(csn, picopass_iclass_key, div_key);
-    loclass_opt_doReaderMAC(ccnr, div_key, mac);
-
-    return rfalPicoPassPollerCheck(mac, &chkRes);
-}
-
-static ReturnCode picopass_auth_factory(uint8_t* csn, uint8_t* div_key) {
-    rfalPicoPassReadCheckRes rcRes;
-    rfalPicoPassCheckRes chkRes;
-
-    ReturnCode err;
-
-    uint8_t mac[4] = {0};
-    uint8_t ccnr[12] = {0};
-
-    err = rfalPicoPassPollerReadCheck(&rcRes);
-    if(err != ERR_NONE) {
-        FURI_LOG_E(TAG, "rfalPicoPassPollerReadCheck error %d", err);
-        return err;
-    }
-    memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
-
-    loclass_diversifyKey(csn, picopass_factory_debit_key, div_key);
-    loclass_opt_doReaderMAC(ccnr, div_key, mac);
-
-    return rfalPicoPassPollerCheck(mac, &chkRes);
-}
-
 static ReturnCode picopass_auth_dict(
     uint8_t* csn,
     PicopassPacs* pacs,
     uint8_t* div_key,
-    IclassEliteDictType dict_type) {
+    IclassEliteDictType dict_type,
+    bool elite) {
     rfalPicoPassReadCheckRes rcRes;
     rfalPicoPassCheckRes chkRes;
 
@@ -269,7 +222,7 @@ static ReturnCode picopass_auth_dict(
         }
         memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
 
-        loclass_iclass_calc_div_key(csn, key, div_key, true);
+        loclass_iclass_calc_div_key(csn, key, div_key, elite);
         loclass_opt_doReaderMAC(ccnr, div_key, mac);
 
         err = rfalPicoPassPollerCheck(mac, &chkRes);
@@ -287,38 +240,35 @@ static ReturnCode picopass_auth_dict(
 ReturnCode picopass_auth(PicopassBlock* AA1, PicopassPacs* pacs) {
     ReturnCode err;
 
-    FURI_LOG_I(TAG, "Trying standard legacy key");
-    err = picopass_auth_standard(
-        AA1[PICOPASS_CSN_BLOCK_INDEX].data, AA1[PICOPASS_KD_BLOCK_INDEX].data);
-    if(err == ERR_NONE) {
-        memcpy(pacs->key, picopass_iclass_key, PICOPASS_BLOCK_LEN);
-        return ERR_NONE;
-    }
-
-    FURI_LOG_I(TAG, "Trying factory default key");
-    err = picopass_auth_factory(
-        AA1[PICOPASS_CSN_BLOCK_INDEX].data, AA1[PICOPASS_KD_BLOCK_INDEX].data);
+    FURI_LOG_I(TAG, "Starting system dictionary attack [Standard KDF]");
+    err = picopass_auth_dict(
+        AA1[PICOPASS_CSN_BLOCK_INDEX].data,
+        pacs,
+        AA1[PICOPASS_KD_BLOCK_INDEX].data,
+        IclassEliteDictTypeFlipper,
+        false);
     if(err == ERR_NONE) {
-        memcpy(pacs->key, picopass_factory_debit_key, PICOPASS_BLOCK_LEN);
         return ERR_NONE;
     }
 
-    FURI_LOG_I(TAG, "Starting user dictionary attack");
+    FURI_LOG_I(TAG, "Starting user dictionary attack [Elite KDF]");
     err = picopass_auth_dict(
         AA1[PICOPASS_CSN_BLOCK_INDEX].data,
         pacs,
         AA1[PICOPASS_KD_BLOCK_INDEX].data,
-        IclassEliteDictTypeUser);
+        IclassEliteDictTypeUser,
+        true);
     if(err == ERR_NONE) {
         return ERR_NONE;
     }
 
-    FURI_LOG_I(TAG, "Starting system dictionary attack");
+    FURI_LOG_I(TAG, "Starting system dictionary attack [Elite KDF]");
     err = picopass_auth_dict(
         AA1[PICOPASS_CSN_BLOCK_INDEX].data,
         pacs,
         AA1[PICOPASS_KD_BLOCK_INDEX].data,
-        IclassEliteDictTypeFlipper);
+        IclassEliteDictTypeFlipper,
+        true);
     if(err == ERR_NONE) {
         return ERR_NONE;
     }
@@ -396,7 +346,7 @@ ReturnCode picopass_write_card(PicopassBlock* AA1) {
     }
     memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
 
-    loclass_diversifyKey(selRes.CSN, picopass_iclass_key, div_key);
+    loclass_iclass_calc_div_key(selRes.CSN, (uint8_t*)picopass_iclass_key, div_key, false);
     loclass_opt_doReaderMAC(ccnr, div_key, mac);
 
     err = rfalPicoPassPollerCheck(mac, &chkRes);
@@ -438,7 +388,7 @@ ReturnCode picopass_write_card(PicopassBlock* AA1) {
     return ERR_NONE;
 }
 
-ReturnCode picopass_write_block(PicopassPacs* pacs, uint8_t blockNo, uint8_t* newBlock) {
+ReturnCode picopass_write_block(PicopassBlock* AA1, uint8_t blockNo, uint8_t* newBlock) {
     rfalPicoPassIdentifyRes idRes;
     rfalPicoPassSelectRes selRes;
     rfalPicoPassReadCheckRes rcRes;
@@ -446,7 +396,6 @@ ReturnCode picopass_write_block(PicopassPacs* pacs, uint8_t blockNo, uint8_t* ne
 
     ReturnCode err;
 
-    uint8_t div_key[8] = {0};
     uint8_t mac[4] = {0};
     uint8_t ccnr[12] = {0};
 
@@ -469,9 +418,12 @@ ReturnCode picopass_write_block(PicopassPacs* pacs, uint8_t blockNo, uint8_t* ne
     }
     memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
 
-    loclass_diversifyKey(selRes.CSN, pacs->key, div_key);
-    loclass_opt_doReaderMAC(ccnr, div_key, mac);
+    if(memcmp(selRes.CSN, AA1[PICOPASS_CSN_BLOCK_INDEX].data, PICOPASS_BLOCK_LEN) != 0) {
+        FURI_LOG_E(TAG, "Wrong CSN for write");
+        return ERR_REQUEST;
+    }
 
+    loclass_opt_doReaderMAC(ccnr, AA1[PICOPASS_KD_BLOCK_INDEX].data, mac);
     err = rfalPicoPassPollerCheck(mac, &chkRes);
     if(err != ERR_NONE) {
         FURI_LOG_E(TAG, "rfalPicoPassPollerCheck error %d", err);
@@ -489,7 +441,7 @@ ReturnCode picopass_write_block(PicopassPacs* pacs, uint8_t blockNo, uint8_t* ne
         newBlock[5],
         newBlock[6],
         newBlock[7]};
-    loclass_doMAC_N(data, sizeof(data), div_key, mac);
+    loclass_doMAC_N(data, sizeof(data), AA1[PICOPASS_KD_BLOCK_INDEX].data, mac);
     FURI_LOG_D(
         TAG,
         "loclass_doMAC_N %d %02x%02x%02x%02x%02x%02x%02x%02x %02x%02x%02x%02x",
@@ -524,8 +476,8 @@ int32_t picopass_worker_task(void* context) {
         picopass_worker_detect(picopass_worker);
     } else if(picopass_worker->state == PicopassWorkerStateWrite) {
         picopass_worker_write(picopass_worker);
-    } else if(picopass_worker->state == PicopassWorkerStateWriteStandardKey) {
-        picopass_worker_write_standard_key(picopass_worker);
+    } else if(picopass_worker->state == PicopassWorkerStateWriteKey) {
+        picopass_worker_write_key(picopass_worker);
     }
     picopass_worker_disable_field(ERR_NONE);
 
@@ -633,7 +585,7 @@ void picopass_worker_write(PicopassWorker* picopass_worker) {
     }
 }
 
-void picopass_worker_write_standard_key(PicopassWorker* picopass_worker) {
+void picopass_worker_write_key(PicopassWorker* picopass_worker) {
     PicopassDeviceData* dev_data = picopass_worker->dev_data;
     PicopassBlock* AA1 = dev_data->AA1;
     PicopassPacs* pacs = &dev_data->pacs;
@@ -646,7 +598,7 @@ void picopass_worker_write_standard_key(PicopassWorker* picopass_worker) {
     uint8_t* oldKey = AA1[PICOPASS_KD_BLOCK_INDEX].data;
 
     uint8_t newKey[PICOPASS_BLOCK_LEN] = {0};
-    loclass_diversifyKey(csn, picopass_iclass_key, newKey);
+    loclass_iclass_calc_div_key(csn, pacs->key, newKey, false);
 
     if((fuses & 0x80) == 0x80) {
         FURI_LOG_D(TAG, "Plain write for personalized mode key change");
@@ -658,9 +610,9 @@ void picopass_worker_write_standard_key(PicopassWorker* picopass_worker) {
         }
     }
 
-    while(picopass_worker->state == PicopassWorkerStateWriteStandardKey) {
+    while(picopass_worker->state == PicopassWorkerStateWriteKey) {
         if(picopass_detect_card(1000) == ERR_NONE) {
-            err = picopass_write_block(pacs, PICOPASS_KD_BLOCK_INDEX, newKey);
+            err = picopass_write_block(AA1, PICOPASS_KD_BLOCK_INDEX, newKey);
             if(err != ERR_NONE) {
                 FURI_LOG_E(TAG, "picopass_write_block error %d", err);
                 nextState = PicopassWorkerEventFail;
diff --git a/applications/plugins/picopass/picopass_worker.h b/applications/plugins/picopass/picopass_worker.h
index 775212c661..f5e9f3039b 100644
--- a/applications/plugins/picopass/picopass_worker.h
+++ b/applications/plugins/picopass/picopass_worker.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "picopass_device.h"
+#include "picopass_keys.h"
 
 typedef struct PicopassWorker PicopassWorker;
 
@@ -12,7 +13,7 @@ typedef enum {
     // Main worker states
     PicopassWorkerStateDetect,
     PicopassWorkerStateWrite,
-    PicopassWorkerStateWriteStandardKey,
+    PicopassWorkerStateWriteKey,
     // Transition
     PicopassWorkerStateStop,
 } PicopassWorkerState;
diff --git a/applications/plugins/picopass/picopass_worker_i.h b/applications/plugins/picopass/picopass_worker_i.h
index cf55fbdf58..f41cfce45d 100644
--- a/applications/plugins/picopass/picopass_worker_i.h
+++ b/applications/plugins/picopass/picopass_worker_i.h
@@ -31,4 +31,4 @@ int32_t picopass_worker_task(void* context);
 
 void picopass_worker_detect(PicopassWorker* picopass_worker);
 void picopass_worker_write(PicopassWorker* picopass_worker);
-void picopass_worker_write_standard_key(PicopassWorker* picopass_worker);
+void picopass_worker_write_key(PicopassWorker* picopass_worker);
diff --git a/applications/plugins/picopass/scenes/picopass_scene_card_menu.c b/applications/plugins/picopass/scenes/picopass_scene_card_menu.c
index a424b919a7..fe63f7c86b 100644
--- a/applications/plugins/picopass/scenes/picopass_scene_card_menu.c
+++ b/applications/plugins/picopass/scenes/picopass_scene_card_menu.c
@@ -3,6 +3,7 @@
 enum SubmenuIndex {
     SubmenuIndexSave,
     SubmenuIndexSaveAsLF,
+    SubmenuIndexChangeKey,
 };
 
 void picopass_scene_card_menu_submenu_callback(void* context, uint32_t index) {
@@ -25,6 +26,13 @@ void picopass_scene_card_menu_on_enter(void* context) {
             picopass_scene_card_menu_submenu_callback,
             picopass);
     }
+    submenu_add_item(
+        submenu,
+        "Change Key",
+        SubmenuIndexChangeKey,
+        picopass_scene_card_menu_submenu_callback,
+        picopass);
+
     submenu_set_selected_item(
         picopass->submenu,
         scene_manager_get_scene_state(picopass->scene_manager, PicopassSceneCardMenu));
@@ -49,6 +57,11 @@ bool picopass_scene_card_menu_on_event(void* context, SceneManagerEvent event) {
             picopass->dev->format = PicopassDeviceSaveFormatLF;
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneSaveName);
             consumed = true;
+        } else if(event.event == SubmenuIndexChangeKey) {
+            scene_manager_set_scene_state(
+                picopass->scene_manager, PicopassSceneCardMenu, SubmenuIndexChangeKey);
+            scene_manager_next_scene(picopass->scene_manager, PicopassSceneKeyMenu);
+            consumed = true;
         }
     } else if(event.type == SceneManagerEventTypeBack) {
         consumed = scene_manager_search_and_switch_to_previous_scene(
diff --git a/applications/plugins/picopass/scenes/picopass_scene_config.h b/applications/plugins/picopass/scenes/picopass_scene_config.h
index 95700787fb..f5a90d46e4 100644
--- a/applications/plugins/picopass/scenes/picopass_scene_config.h
+++ b/applications/plugins/picopass/scenes/picopass_scene_config.h
@@ -13,3 +13,4 @@ ADD_SCENE(picopass, write_card, WriteCard)
 ADD_SCENE(picopass, write_card_success, WriteCardSuccess)
 ADD_SCENE(picopass, read_factory_success, ReadFactorySuccess)
 ADD_SCENE(picopass, write_key, WriteKey)
+ADD_SCENE(picopass, key_menu, KeyMenu)
diff --git a/applications/plugins/picopass/scenes/picopass_scene_key_menu.c b/applications/plugins/picopass/scenes/picopass_scene_key_menu.c
new file mode 100644
index 0000000000..8aac6cb249
--- /dev/null
+++ b/applications/plugins/picopass/scenes/picopass_scene_key_menu.c
@@ -0,0 +1,96 @@
+#include "../picopass_i.h"
+#include "../picopass_keys.h"
+
+enum SubmenuIndex {
+    SubmenuIndexWriteStandard,
+    SubmenuIndexWriteiCE,
+    SubmenuIndexWriteiCL,
+    SubmenuIndexWriteiCS,
+    SubmenuIndexWriteCustom, //TODO: user input of key
+};
+
+void picopass_scene_key_menu_submenu_callback(void* context, uint32_t index) {
+    Picopass* picopass = context;
+
+    view_dispatcher_send_custom_event(picopass->view_dispatcher, index);
+}
+
+void picopass_scene_key_menu_on_enter(void* context) {
+    Picopass* picopass = context;
+    Submenu* submenu = picopass->submenu;
+
+    submenu_add_item(
+        submenu,
+        "Write Standard",
+        SubmenuIndexWriteStandard,
+        picopass_scene_key_menu_submenu_callback,
+        picopass);
+    submenu_add_item(
+        submenu,
+        "Write iCE",
+        SubmenuIndexWriteiCE,
+        picopass_scene_key_menu_submenu_callback,
+        picopass);
+    submenu_add_item(
+        submenu,
+        "Write iCL",
+        SubmenuIndexWriteiCL,
+        picopass_scene_key_menu_submenu_callback,
+        picopass);
+    submenu_add_item(
+        submenu,
+        "Write iCS",
+        SubmenuIndexWriteiCS,
+        picopass_scene_key_menu_submenu_callback,
+        picopass);
+
+    submenu_set_selected_item(
+        picopass->submenu,
+        scene_manager_get_scene_state(picopass->scene_manager, PicopassSceneKeyMenu));
+
+    view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewMenu);
+}
+
+bool picopass_scene_key_menu_on_event(void* context, SceneManagerEvent event) {
+    Picopass* picopass = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexWriteStandard) {
+            scene_manager_set_scene_state(
+                picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteStandard);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_iclass_key, PICOPASS_BLOCK_LEN);
+            scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
+            consumed = true;
+        } else if(event.event == SubmenuIndexWriteiCE) {
+            scene_manager_set_scene_state(
+                picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteiCE);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_xice_key, PICOPASS_BLOCK_LEN);
+            scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
+            consumed = true;
+        } else if(event.event == SubmenuIndexWriteiCL) {
+            scene_manager_set_scene_state(
+                picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteiCE);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_xicl_key, PICOPASS_BLOCK_LEN);
+            scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
+            consumed = true;
+        } else if(event.event == SubmenuIndexWriteiCS) {
+            scene_manager_set_scene_state(
+                picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteiCE);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_xics_key, PICOPASS_BLOCK_LEN);
+            scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
+            consumed = true;
+        }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        consumed = scene_manager_search_and_switch_to_previous_scene(
+            picopass->scene_manager, PicopassSceneStart);
+    }
+
+    return consumed;
+}
+
+void picopass_scene_key_menu_on_exit(void* context) {
+    Picopass* picopass = context;
+
+    submenu_reset(picopass->submenu);
+}
diff --git a/applications/plugins/picopass/scenes/picopass_scene_read_card.c b/applications/plugins/picopass/scenes/picopass_scene_read_card.c
index 90422a2e73..96ec7c668b 100644
--- a/applications/plugins/picopass/scenes/picopass_scene_read_card.c
+++ b/applications/plugins/picopass/scenes/picopass_scene_read_card.c
@@ -1,7 +1,6 @@
 #include "../picopass_i.h"
 #include <dolphin/dolphin.h>
-
-const uint8_t picopass_factory_key_check[] = {0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87};
+#include "../picopass_keys.h"
 
 void picopass_read_card_worker_callback(PicopassWorkerEvent event, void* context) {
     UNUSED(event);
@@ -38,7 +37,7 @@ bool picopass_scene_read_card_on_event(void* context, SceneManagerEvent event) {
         if(event.event == PicopassCustomEventWorkerExit) {
             if(memcmp(
                    picopass->dev->dev_data.pacs.key,
-                   picopass_factory_key_check,
+                   picopass_factory_debit_key,
                    PICOPASS_BLOCK_LEN) == 0) {
                 scene_manager_next_scene(picopass->scene_manager, PicopassSceneReadFactorySuccess);
             } else {
diff --git a/applications/plugins/picopass/scenes/picopass_scene_read_factory_success.c b/applications/plugins/picopass/scenes/picopass_scene_read_factory_success.c
index 8e32d21f7b..bc07bb9530 100644
--- a/applications/plugins/picopass/scenes/picopass_scene_read_factory_success.c
+++ b/applications/plugins/picopass/scenes/picopass_scene_read_factory_success.c
@@ -1,5 +1,6 @@
 #include "../picopass_i.h"
 #include <dolphin/dolphin.h>
+#include "../picopass_keys.h"
 
 void picopass_scene_read_factory_success_widget_callback(
     GuiButtonType result,
@@ -63,6 +64,7 @@ bool picopass_scene_read_factory_success_on_event(void* context, SceneManagerEve
         if(event.event == GuiButtonTypeLeft) {
             consumed = scene_manager_previous_scene(picopass->scene_manager);
         } else if(event.event == GuiButtonTypeCenter) {
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_iclass_key, PICOPASS_BLOCK_LEN);
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
             consumed = true;
         }
diff --git a/applications/plugins/picopass/scenes/picopass_scene_save_name.c b/applications/plugins/picopass/scenes/picopass_scene_save_name.c
index 59f33c79a0..baf882b807 100644
--- a/applications/plugins/picopass/scenes/picopass_scene_save_name.c
+++ b/applications/plugins/picopass/scenes/picopass_scene_save_name.c
@@ -31,12 +31,10 @@ void picopass_scene_save_name_on_enter(void* context) {
         dev_name_empty);
 
     FuriString* folder_path;
-    folder_path = furi_string_alloc();
+    folder_path = furi_string_alloc_set(STORAGE_APP_DATA_PATH_PREFIX);
 
     if(furi_string_end_with(picopass->dev->load_path, PICOPASS_APP_EXTENSION)) {
         path_extract_dirname(furi_string_get_cstr(picopass->dev->load_path), folder_path);
-    } else {
-        furi_string_set(folder_path, PICOPASS_APP_FOLDER);
     }
 
     ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
diff --git a/applications/plugins/picopass/scenes/picopass_scene_write_key.c b/applications/plugins/picopass/scenes/picopass_scene_write_key.c
index 83d594ca2b..0f417e1c3f 100644
--- a/applications/plugins/picopass/scenes/picopass_scene_write_key.c
+++ b/applications/plugins/picopass/scenes/picopass_scene_write_key.c
@@ -20,7 +20,7 @@ void picopass_scene_write_key_on_enter(void* context) {
     view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewPopup);
     picopass_worker_start(
         picopass->worker,
-        PicopassWorkerStateWriteStandardKey,
+        PicopassWorkerStateWriteKey,
         &picopass->dev->dev_data,
         picopass_write_key_worker_callback,
         picopass);
diff --git a/applications/plugins/playlist/playlist.c b/applications/plugins/playlist/playlist.c
index 9946fb95be..b32ed2178f 100644
--- a/applications/plugins/playlist/playlist.c
+++ b/applications/plugins/playlist/playlist.c
@@ -61,6 +61,8 @@ typedef struct {
 
     bool ctl_request_exit; // can be set to true if the worker should exit
     bool ctl_pause; // can be set to true if the worker should pause
+    bool ctl_request_skip; // can be set to true if the worker should skip the current file
+    bool ctl_request_prev; // can be set to true if the worker should go to the previous file
 
     bool is_running; // indicates if the worker is running
 } PlaylistWorker;
@@ -185,6 +187,18 @@ static int playlist_worker_process(
             status = 1;
             break;
         }
+        if(worker->ctl_request_skip) {
+            worker->ctl_request_skip = false;
+            FURI_LOG_D(TAG, "    (TX) Requested to skip. Cancelling and resending...");
+            status = 0;
+            break;
+        }
+        if(worker->ctl_request_prev) {
+            worker->ctl_request_prev = false;
+            FURI_LOG_D(TAG, "    (TX) Requested to prev. Cancelling and resending...");
+            status = 3;
+            break;
+        }
         furi_delay_ms(50);
     }
 
@@ -213,6 +227,22 @@ static bool playlist_worker_wait_pause(PlaylistWorker* worker) {
     return true;
 }
 
+void updatePlayListView(PlaylistWorker* worker, const char* str) {
+    furi_string_reset(worker->meta->prev_3_path);
+    furi_string_set(worker->meta->prev_3_path, furi_string_get_cstr(worker->meta->prev_2_path));
+
+    furi_string_reset(worker->meta->prev_2_path);
+    furi_string_set(worker->meta->prev_2_path, furi_string_get_cstr(worker->meta->prev_1_path));
+
+    furi_string_reset(worker->meta->prev_1_path);
+    furi_string_set(worker->meta->prev_1_path, furi_string_get_cstr(worker->meta->prev_0_path));
+
+    furi_string_reset(worker->meta->prev_0_path);
+    furi_string_set(worker->meta->prev_0_path, str);
+
+    view_port_update(worker->meta->view_port);
+}
+
 static bool playlist_worker_play_playlist_once(
     PlaylistWorker* worker,
     Storage* storage,
@@ -226,6 +256,7 @@ static bool playlist_worker_play_playlist_once(
         FURI_LOG_E(TAG, "Failed to rewind file");
         return false;
     }
+
     while(flipper_format_read_string(fff_head, "sub", data)) {
         if(!playlist_worker_wait_pause(worker)) {
             break;
@@ -238,18 +269,7 @@ static bool playlist_worker_play_playlist_once(
         const char* str = furi_string_get_cstr(data);
 
         // it's not fancy, but it works for now :)
-        furi_string_reset(worker->meta->prev_3_path);
-        furi_string_set(
-            worker->meta->prev_3_path, furi_string_get_cstr(worker->meta->prev_2_path));
-        furi_string_reset(worker->meta->prev_2_path);
-        furi_string_set(
-            worker->meta->prev_2_path, furi_string_get_cstr(worker->meta->prev_1_path));
-        furi_string_reset(worker->meta->prev_1_path);
-        furi_string_set(
-            worker->meta->prev_1_path, furi_string_get_cstr(worker->meta->prev_0_path));
-        furi_string_reset(worker->meta->prev_0_path);
-        furi_string_set(worker->meta->prev_0_path, str);
-        view_port_update(worker->meta->view_port);
+        updatePlayListView(worker, str);
 
         for(int i = 0; i < 1; i++) {
             if(!playlist_worker_wait_pause(worker)) {
@@ -279,6 +299,23 @@ static bool playlist_worker_play_playlist_once(
                 // exited, exit loop
             } else if(status == 2) {
                 return false;
+            } else if(status == 3) {
+                //aqui rebobinamos y avanzamos de nuevo el fichero n-1 veces
+                //decrementamos el contador de ficheros enviados
+                worker->meta->current_count--;
+                if(worker->meta->current_count > 0) {
+                    worker->meta->current_count--;
+                }
+                //rebobinamos el fichero
+                if(!flipper_format_rewind(fff_head)) {
+                    FURI_LOG_E(TAG, "Failed to rewind file");
+                    return false;
+                }
+                //avanzamos el fichero n-1 veces
+                for(int j = 0; j < worker->meta->current_count; j++) {
+                    flipper_format_read_string(fff_head, "sub", data);
+                }
+                break;
             }
         }
     } // end of loop
@@ -591,6 +628,8 @@ static void render_callback(Canvas* canvas, void* ctx) {
             }
         }
         break;
+    default:
+        break;
     }
 
     furi_string_free(temp_str);
@@ -672,6 +711,9 @@ int32_t playlist_app(void* p) {
     Playlist* app = playlist_alloc(meta);
     meta->view_port = app->view_port;
 
+    // Enable power for External CC1101 if it is connected
+    furi_hal_subghz_enable_ext_power();
+
     furi_hal_power_suppress_charge_enter();
 
     // select playlist file
@@ -708,6 +750,10 @@ int32_t playlist_app(void* p) {
                 if(input.type == InputTypeShort && app->meta->playlist_repetitions > 0) {
                     --app->meta->playlist_repetitions;
                 }
+            } else if(app->meta->state == STATE_SENDING) {
+                if(input.type == InputTypeShort) {
+                    app->worker->ctl_request_prev = true;
+                }
             }
             break;
 
@@ -716,6 +762,10 @@ int32_t playlist_app(void* p) {
                 if(input.type == InputTypeShort) {
                     ++app->meta->playlist_repetitions;
                 }
+            } else if(app->meta->state == STATE_SENDING) {
+                if(input.type == InputTypeShort) {
+                    app->worker->ctl_request_skip = true;
+                }
             }
             break;
 
@@ -752,6 +802,8 @@ int32_t playlist_app(void* p) {
 exit_cleanup:
 
     furi_hal_power_suppress_charge_exit();
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
 
     if(app->worker != NULL) {
         if(playlist_worker_running(app->worker)) {
diff --git a/applications/plugins/pocsag_pager/pocsag_pager_app.c b/applications/plugins/pocsag_pager/pocsag_pager_app.c
index 3ac2423047..123b3ee9d9 100644
--- a/applications/plugins/pocsag_pager/pocsag_pager_app.c
+++ b/applications/plugins/pocsag_pager/pocsag_pager_app.c
@@ -122,6 +122,9 @@ POCSAGPagerApp* pocsag_pager_app_alloc() {
         app->txrx->worker, (SubGhzWorkerPairCallback)subghz_receiver_decode);
     subghz_worker_set_context(app->txrx->worker, app->txrx->receiver);
 
+    // Enable power for External CC1101 if it is connected
+    furi_hal_subghz_enable_ext_power();
+
     furi_hal_power_suppress_charge_enter();
 
     scene_manager_next_scene(app->scene_manager, POCSAGPagerSceneStart);
@@ -135,6 +138,9 @@ void pocsag_pager_app_free(POCSAGPagerApp* app) {
     //CC1101 off
     pcsg_sleep(app);
 
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
+
     // Submenu
     view_dispatcher_remove_view(app->view_dispatcher, POCSAGPagerViewSubmenu);
     submenu_free(app->submenu);
diff --git a/applications/plugins/pocsag_pager/protocols/pcsg_generic.c b/applications/plugins/pocsag_pager/protocols/pcsg_generic.c
index 890ed43d7f..5425fd512d 100644
--- a/applications/plugins/pocsag_pager/protocols/pcsg_generic.c
+++ b/applications/plugins/pocsag_pager/protocols/pcsg_generic.c
@@ -21,12 +21,12 @@ void pcsg_block_generic_get_preset_name(const char* preset_name, FuriString* pre
     furi_string_set(preset_str, preset_name_temp);
 }
 
-bool pcsg_block_generic_serialize(
+SubGhzProtocolStatus pcsg_block_generic_serialize(
     PCSGBlockGeneric* instance,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(instance);
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     do {
@@ -75,15 +75,16 @@ bool pcsg_block_generic_serialize(
             break;
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
     furi_string_free(temp_str);
     return res;
 }
 
-bool pcsg_block_generic_deserialize(PCSGBlockGeneric* instance, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    pcsg_block_generic_deserialize(PCSGBlockGeneric* instance, FlipperFormat* flipper_format) {
     furi_assert(instance);
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_data = furi_string_alloc();
     FuriString* temp_data2 = furi_string_alloc();
 
@@ -113,7 +114,7 @@ bool pcsg_block_generic_deserialize(PCSGBlockGeneric* instance, FlipperFormat* f
             instance->result_msg = furi_string_alloc_set(temp_data);
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(0);
 
     furi_string_free(temp_data);
diff --git a/applications/plugins/pocsag_pager/protocols/pcsg_generic.h b/applications/plugins/pocsag_pager/protocols/pcsg_generic.h
index ff925b6c94..126b54ffe9 100644
--- a/applications/plugins/pocsag_pager/protocols/pcsg_generic.h
+++ b/applications/plugins/pocsag_pager/protocols/pcsg_generic.h
@@ -35,7 +35,7 @@ void pcsg_block_generic_get_preset_name(const char* preset_name, FuriString* pre
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
  * @return true On success
  */
-bool pcsg_block_generic_serialize(
+SubGhzProtocolStatus pcsg_block_generic_serialize(
     PCSGBlockGeneric* instance,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -46,7 +46,8 @@ bool pcsg_block_generic_serialize(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool pcsg_block_generic_deserialize(PCSGBlockGeneric* instance, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    pcsg_block_generic_deserialize(PCSGBlockGeneric* instance, FlipperFormat* flipper_format);
 
 float pcsg_block_generic_fahrenheit_to_celsius(float fahrenheit);
 
diff --git a/applications/plugins/pocsag_pager/protocols/pocsag.c b/applications/plugins/pocsag_pager/protocols/pocsag.c
index 69d09d554b..ca210c2a46 100644
--- a/applications/plugins/pocsag_pager/protocols/pocsag.c
+++ b/applications/plugins/pocsag_pager/protocols/pocsag.c
@@ -288,7 +288,7 @@ uint8_t subghz_protocol_decoder_pocsag_get_hash_data(void* context) {
     return hash;
 }
 
-bool subghz_protocol_decoder_pocsag_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_pocsag_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -296,31 +296,35 @@ bool subghz_protocol_decoder_pocsag_serialize(
     SubGhzProtocolDecoderPocsag* instance = context;
     uint32_t msg_len;
 
-    if(!pcsg_block_generic_serialize(&instance->generic, flipper_format, preset)) return false;
+    if(SubGhzProtocolStatusOk !=
+       pcsg_block_generic_serialize(&instance->generic, flipper_format, preset))
+        return SubGhzProtocolStatusError;
 
     msg_len = furi_string_size(instance->done_msg);
     if(!flipper_format_write_uint32(flipper_format, "MsgLen", &msg_len, 1)) {
         FURI_LOG_E(TAG, "Error adding MsgLen");
-        return false;
+        return SubGhzProtocolStatusError;
     }
 
     uint8_t* s = (uint8_t*)furi_string_get_cstr(instance->done_msg);
     if(!flipper_format_write_hex(flipper_format, "Msg", s, msg_len)) {
         FURI_LOG_E(TAG, "Error adding Msg");
-        return false;
+        return SubGhzProtocolStatusError;
     }
-    return true;
+    return SubGhzProtocolStatusOk;
 }
 
-bool subghz_protocol_decoder_pocsag_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_pocsag_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderPocsag* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     uint32_t msg_len;
     uint8_t* buf;
 
     do {
-        if(!pcsg_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           pcsg_block_generic_deserialize(&instance->generic, flipper_format)) {
             break;
         }
 
@@ -338,7 +342,7 @@ bool subghz_protocol_decoder_pocsag_deserialize(void* context, FlipperFormat* fl
         furi_string_set_strn(instance->done_msg, (const char*)buf, msg_len);
         free(buf);
 
-        ret = true;
+        ret = SubGhzProtocolStatusOk;
     } while(false);
     return ret;
 }
diff --git a/applications/plugins/protoview/app.c b/applications/plugins/protoview/app.c
index d27b3a54a6..a4dab9f40f 100644
--- a/applications/plugins/protoview/app.c
+++ b/applications/plugins/protoview/app.c
@@ -167,6 +167,9 @@ ProtoViewApp* protoview_app_alloc() {
     app->frequency = subghz_setting_get_default_frequency(app->setting);
     app->modulation = 0; /* Defaults to ProtoViewModulations[0]. */
 
+    // Enable power for External CC1101 if it is connected
+    furi_hal_subghz_enable_ext_power();
+
     furi_hal_power_suppress_charge_enter();
     app->running = 1;
 
@@ -182,6 +185,9 @@ void protoview_app_free(ProtoViewApp* app) {
     // Put CC1101 on sleep, this also restores charging.
     radio_sleep(app);
 
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
+
     // View related.
     view_port_enabled_set(app->view_port, false);
     gui_remove_view_port(app->gui, app->view_port);
diff --git a/applications/plugins/sentry_safe/sentry_safe.c b/applications/plugins/sentry_safe/sentry_safe.c
index 4d9c12fc78..789b43f2c3 100644
--- a/applications/plugins/sentry_safe/sentry_safe.c
+++ b/applications/plugins/sentry_safe/sentry_safe.c
@@ -7,6 +7,7 @@
 
 typedef struct {
     uint8_t status;
+    FuriMutex* mutex;
 } SentryState;
 
 typedef enum {
@@ -22,10 +23,9 @@ typedef struct {
 const char* status_texts[3] = {"[Press OK to open safe]", "Sending...", "Done !"};
 
 static void sentry_safe_render_callback(Canvas* const canvas, void* ctx) {
-    const SentryState* sentry_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(sentry_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const SentryState* sentry_state = ctx;
+    furi_mutex_acquire(sentry_state->mutex, FuriWaitForever);
 
     // Before the function is called, the state is set with the canvas_reset(canvas)
 
@@ -41,7 +41,7 @@ static void sentry_safe_render_callback(Canvas* const canvas, void* ctx) {
     canvas_draw_str_aligned(
         canvas, 64, 50, AlignCenter, AlignBottom, status_texts[sentry_state->status]);
 
-    release_mutex((ValueMutex*)ctx, sentry_state);
+    furi_mutex_release(sentry_state->mutex);
 }
 
 static void sentry_safe_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -89,8 +89,8 @@ int32_t sentry_safe_app(void* p) {
 
     sentry_state->status = 0;
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, sentry_state, sizeof(SentryState))) {
+    sentry_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!sentry_state->mutex) {
         FURI_LOG_E("SentrySafe", "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(sentry_state);
@@ -98,7 +98,7 @@ int32_t sentry_safe_app(void* p) {
     }
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, sentry_safe_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, sentry_safe_render_callback, sentry_state);
     view_port_input_callback_set(view_port, sentry_safe_input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -109,7 +109,7 @@ int32_t sentry_safe_app(void* p) {
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
-        SentryState* sentry_state = (SentryState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(sentry_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -151,7 +151,7 @@ int32_t sentry_safe_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, sentry_state);
+        furi_mutex_release(sentry_state->mutex);
     }
 
     // Reset GPIO pins to default state
@@ -162,7 +162,7 @@ int32_t sentry_safe_app(void* p) {
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(sentry_state->mutex);
     free(sentry_state);
 
     return 0;
diff --git a/applications/plugins/snake_game/snake_game.c b/applications/plugins/snake_game/snake_game.c
index eb020b7b93..00cf04e315 100644
--- a/applications/plugins/snake_game/snake_game.c
+++ b/applications/plugins/snake_game/snake_game.c
@@ -50,6 +50,7 @@ typedef struct {
     Direction nextMovement; // if backward of currentMovement, ignore
     Point fruit;
     GameState state;
+    FuriMutex* mutex;
 } SnakeState;
 
 typedef enum {
@@ -92,12 +93,10 @@ const NotificationSequence sequence_eat = {
 };
 
 static void snake_game_render_callback(Canvas* const canvas, void* ctx) {
-    const SnakeState* snake_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(snake_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const SnakeState* snake_state = ctx;
 
-    // Before the function is called, the state is set with the canvas_reset(canvas)
+    furi_mutex_acquire(snake_state->mutex, FuriWaitForever);
 
     // Frame
     canvas_draw_frame(canvas, 0, 0, 128, 64);
@@ -134,7 +133,7 @@ static void snake_game_render_callback(Canvas* const canvas, void* ctx) {
         canvas_draw_str_aligned(canvas, 64, 41, AlignCenter, AlignBottom, buffer);
     }
 
-    release_mutex((ValueMutex*)ctx, snake_state);
+    furi_mutex_release(snake_state->mutex);
 }
 
 static void snake_game_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -321,8 +320,9 @@ int32_t snake_game_app(void* p) {
     SnakeState* snake_state = malloc(sizeof(SnakeState));
     snake_game_init_game(snake_state);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, snake_state, sizeof(SnakeState))) {
+    snake_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+
+    if(!snake_state->mutex) {
         FURI_LOG_E("SnakeGame", "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(snake_state);
@@ -330,7 +330,7 @@ int32_t snake_game_app(void* p) {
     }
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, snake_game_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, snake_game_render_callback, snake_state);
     view_port_input_callback_set(view_port, snake_game_input_callback, event_queue);
 
     FuriTimer* timer =
@@ -350,7 +350,7 @@ int32_t snake_game_app(void* p) {
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
-        SnakeState* snake_state = (SnakeState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(snake_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // press events
@@ -389,7 +389,7 @@ int32_t snake_game_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, snake_state);
+        furi_mutex_release(snake_state->mutex);
     }
 
     // Return backlight to normal state
@@ -402,7 +402,7 @@ int32_t snake_game_app(void* p) {
     furi_record_close(RECORD_NOTIFICATION);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(snake_state->mutex);
     free(snake_state);
 
     return 0;
diff --git a/applications/plugins/solitaire/defines.h b/applications/plugins/solitaire/defines.h
index 1456f1964d..8734395e8e 100644
--- a/applications/plugins/solitaire/defines.h
+++ b/applications/plugins/solitaire/defines.h
@@ -53,4 +53,5 @@ typedef struct {
     int8_t selected_card;
     CardAnimation animation;
     uint8_t* buffer;
+    FuriMutex* mutex;
 } GameState;
\ No newline at end of file
diff --git a/applications/plugins/solitaire/solitaire.c b/applications/plugins/solitaire/solitaire.c
index 26e0187ddd..c9de533d3f 100644
--- a/applications/plugins/solitaire/solitaire.c
+++ b/applications/plugins/solitaire/solitaire.c
@@ -155,10 +155,9 @@ static void draw_animation(Canvas* const canvas, const GameState* game_state) {
 }
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const GameState* game_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(game_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const GameState* game_state = ctx;
+    furi_mutex_acquire(game_state->mutex, FuriWaitForever);
 
     switch(game_state->state) {
     case GameStateAnimate:
@@ -174,7 +173,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
         break;
     }
 
-    release_mutex((ValueMutex*)ctx, game_state);
+    furi_mutex_release(game_state->mutex);
 }
 
 void remove_drag(GameState* game_state) {
@@ -470,8 +469,8 @@ int32_t solitaire_app(void* p) {
     game_state->state = GameStateStart;
 
     game_state->processing = true;
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, game_state, sizeof(GameState))) {
+    game_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!game_state->mutex) {
         FURI_LOG_E(APP_NAME, "cannot create mutex\r\n");
         return_code = 255;
         goto free_and_exit;
@@ -481,13 +480,13 @@ int32_t solitaire_app(void* p) {
     notification_message_block(notification, &sequence_display_backlight_enforce_on);
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, game_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     FuriTimer* timer = furi_timer_alloc(update_timer_callback, FuriTimerTypePeriodic, event_queue);
     furi_timer_start(timer, furi_kernel_get_tick_frequency() / 30);
 
-    Gui* gui = furi_record_open("gui");
+    Gui* gui = furi_record_open(RECORD_GUI);
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     AppEvent event;
@@ -497,7 +496,7 @@ int32_t solitaire_app(void* p) {
 
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 150);
-        GameState* localstate = (GameState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(game_state->mutex, FuriWaitForever);
         bool hadChange = false;
         if(event_status == FuriStatusOk) {
             if(event.type == EventTypeKey) {
@@ -509,7 +508,7 @@ int32_t solitaire_app(void* p) {
                     case InputKeyRight:
                     case InputKeyLeft:
                     case InputKeyOk:
-                        localstate->input = event.input.key;
+                        game_state->input = event.input.key;
                         break;
                     case InputKeyBack:
                         processing = false;
@@ -525,12 +524,12 @@ int32_t solitaire_app(void* p) {
                     case InputKeyRight:
                     case InputKeyLeft:
                     case InputKeyOk:
-                        if(event.input.key == InputKeyOk && localstate->state == GameStateStart) {
-                            localstate->state = GameStatePlay;
+                        if(event.input.key == InputKeyOk && game_state->state == GameStateStart) {
+                            game_state->state = GameStatePlay;
                             init(game_state);
                         } else {
                             hadChange = true;
-                            localstate->input = event.input.key;
+                            game_state->input = event.input.key;
                         }
                         break;
                     case InputKeyBack:
@@ -543,16 +542,16 @@ int32_t solitaire_app(void* p) {
                     }
                 }
             } else if(event.type == EventTypeTick) {
-                tick(localstate, notification);
-                processing = localstate->processing;
-                localstate->input = InputKeyMAX;
+                tick(game_state, notification);
+                processing = game_state->processing;
+                game_state->input = InputKeyMAX;
             }
         } else {
             //FURI_LOG_W(APP_NAME, "osMessageQueue: event timeout");
             // event timeout
         }
         if(hadChange || game_state->state == GameStateAnimate) view_port_update(view_port);
-        release_mutex(&state_mutex, localstate);
+        furi_mutex_release(game_state->mutex);
     }
 
     notification_message_block(notification, &sequence_display_backlight_enforce_auto);
@@ -562,7 +561,7 @@ int32_t solitaire_app(void* p) {
     furi_record_close(RECORD_GUI);
     furi_record_close(RECORD_NOTIFICATION);
     view_port_free(view_port);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(game_state->mutex);
 
 free_and_exit:
     free(game_state->animation.buffer);
diff --git a/applications/plugins/spectrum_analyzer/spectrum_analyzer.c b/applications/plugins/spectrum_analyzer/spectrum_analyzer.c
index 8d68c5a1ab..99c12adf7e 100644
--- a/applications/plugins/spectrum_analyzer/spectrum_analyzer.c
+++ b/applications/plugins/spectrum_analyzer/spectrum_analyzer.c
@@ -392,6 +392,9 @@ void spectrum_analyzer_free(SpectrumAnalyzer* instance) {
 
     furi_hal_subghz_idle();
     furi_hal_subghz_sleep();
+
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
 }
 
 int32_t spectrum_analyzer_app(void* p) {
@@ -400,6 +403,9 @@ int32_t spectrum_analyzer_app(void* p) {
     SpectrumAnalyzer* spectrum_analyzer = spectrum_analyzer_alloc();
     InputEvent input;
 
+    // Enable power for External CC1101 if it is connected
+    furi_hal_subghz_enable_ext_power();
+
     furi_hal_power_suppress_charge_enter();
 
     FURI_LOG_D("Spectrum", "Main Loop - Starting worker");
diff --git a/applications/plugins/spi_mem_manager/scenes/spi_mem_scene_start.c b/applications/plugins/spi_mem_manager/scenes/spi_mem_scene_start.c
index b664df687d..38d064a4d2 100644
--- a/applications/plugins/spi_mem_manager/scenes/spi_mem_scene_start.c
+++ b/applications/plugins/spi_mem_manager/scenes/spi_mem_scene_start.c
@@ -60,7 +60,7 @@ bool spi_mem_scene_start_on_event(void* context, SceneManagerEvent event) {
             scene_manager_next_scene(app->scene_manager, SPIMemSceneChipDetect);
             success = true;
         } else if(event.event == SPIMemSceneStartSubmenuIndexSaved) {
-            furi_string_set(app->file_path, SPI_MEM_FILE_FOLDER);
+            furi_string_set(app->file_path, STORAGE_APP_DATA_PATH_PREFIX);
             scene_manager_next_scene(app->scene_manager, SPIMemSceneSelectFile);
             success = true;
         } else if(event.event == SPIMemSceneStartSubmenuIndexErase) {
diff --git a/applications/plugins/spi_mem_manager/spi_mem_app.c b/applications/plugins/spi_mem_manager/spi_mem_app.c
index 63531b74c0..96c3632d05 100644
--- a/applications/plugins/spi_mem_manager/spi_mem_app.c
+++ b/applications/plugins/spi_mem_manager/spi_mem_app.c
@@ -16,9 +16,9 @@ static bool spi_mem_back_event_callback(void* context) {
 }
 
 SPIMemApp* spi_mem_alloc(void) {
-    SPIMemApp* instance = malloc(sizeof(SPIMemApp));
+    SPIMemApp* instance = malloc(sizeof(SPIMemApp)); //-V799
 
-    instance->file_path = furi_string_alloc();
+    instance->file_path = furi_string_alloc_set(STORAGE_APP_DATA_PATH_PREFIX);
     instance->gui = furi_record_open(RECORD_GUI);
     instance->notifications = furi_record_open(RECORD_NOTIFICATION);
     instance->view_dispatcher = view_dispatcher_alloc();
@@ -37,7 +37,8 @@ SPIMemApp* spi_mem_alloc(void) {
     instance->text_input = text_input_alloc();
     instance->mode = SPIMemModeUnknown;
 
-    furi_string_set(instance->file_path, SPI_MEM_FILE_FOLDER);
+    // Migrate data from old sd-card folder
+    storage_common_migrate(instance->storage, EXT_PATH("spimem"), STORAGE_APP_DATA_PATH_PREFIX);
 
     view_dispatcher_enable_queue(instance->view_dispatcher);
     view_dispatcher_set_event_callback_context(instance->view_dispatcher, instance);
@@ -70,7 +71,7 @@ SPIMemApp* spi_mem_alloc(void) {
     furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_external);
     scene_manager_next_scene(instance->scene_manager, SPIMemSceneStart);
     return instance;
-}
+} //-V773
 
 void spi_mem_free(SPIMemApp* instance) {
     view_dispatcher_remove_view(instance->view_dispatcher, SPIMemViewSubmenu);
@@ -105,7 +106,6 @@ void spi_mem_free(SPIMemApp* instance) {
 int32_t spi_mem_app(void* p) {
     UNUSED(p);
     SPIMemApp* instance = spi_mem_alloc();
-    spi_mem_file_create_folder(instance);
     view_dispatcher_run(instance->view_dispatcher);
     spi_mem_free(instance);
     return 0;
diff --git a/applications/plugins/spi_mem_manager/spi_mem_app_i.h b/applications/plugins/spi_mem_manager/spi_mem_app_i.h
index 4ce0561758..285ca66d2f 100644
--- a/applications/plugins/spi_mem_manager/spi_mem_app_i.h
+++ b/applications/plugins/spi_mem_manager/spi_mem_app_i.h
@@ -24,7 +24,6 @@
 
 #define TAG "SPIMem"
 #define SPI_MEM_FILE_EXTENSION ".bin"
-#define SPI_MEM_FILE_FOLDER EXT_PATH("spimem")
 #define SPI_MEM_FILE_NAME_SIZE 100
 #define SPI_MEM_TEXT_BUFFER_SIZE 128
 
diff --git a/applications/plugins/spi_mem_manager/spi_mem_files.c b/applications/plugins/spi_mem_manager/spi_mem_files.c
index a7374da191..9b787bd7f9 100644
--- a/applications/plugins/spi_mem_manager/spi_mem_files.c
+++ b/applications/plugins/spi_mem_manager/spi_mem_files.c
@@ -1,11 +1,5 @@
 #include "spi_mem_app_i.h"
 
-void spi_mem_file_create_folder(SPIMemApp* app) {
-    if(!storage_simply_mkdir(app->storage, SPI_MEM_FILE_FOLDER)) {
-        dialog_message_show_storage_error(app->dialogs, "Cannot create\napp folder");
-    }
-}
-
 bool spi_mem_file_delete(SPIMemApp* app) {
     return (storage_simply_remove(app->storage, furi_string_get_cstr(app->file_path)));
 }
@@ -13,7 +7,7 @@ bool spi_mem_file_delete(SPIMemApp* app) {
 bool spi_mem_file_select(SPIMemApp* app) {
     DialogsFileBrowserOptions browser_options;
     dialog_file_browser_set_basic_options(&browser_options, SPI_MEM_FILE_EXTENSION, &I_Dip8_10px);
-    browser_options.base_path = SPI_MEM_FILE_FOLDER;
+    browser_options.base_path = STORAGE_APP_DATA_PATH_PREFIX;
     bool success =
         dialog_file_browser_show(app->dialogs, app->file_path, app->file_path, &browser_options);
     return success;
diff --git a/applications/plugins/spi_mem_manager/spi_mem_files.h b/applications/plugins/spi_mem_manager/spi_mem_files.h
index 0e735d9519..6a529d3279 100644
--- a/applications/plugins/spi_mem_manager/spi_mem_files.h
+++ b/applications/plugins/spi_mem_manager/spi_mem_files.h
@@ -1,7 +1,6 @@
 #pragma once
 #include "spi_mem_app.h"
 
-void spi_mem_file_create_folder(SPIMemApp* app);
 bool spi_mem_file_select(SPIMemApp* app);
 bool spi_mem_file_create(SPIMemApp* app, const char* file_name);
 bool spi_mem_file_delete(SPIMemApp* app);
diff --git a/applications/plugins/subbrute b/applications/plugins/subbrute
index 7cdb9e1386..19153c7239 160000
--- a/applications/plugins/subbrute
+++ b/applications/plugins/subbrute
@@ -1 +1 @@
-Subproject commit 7cdb9e1386778ad7351f7e3b3389980afaeafea3
+Subproject commit 19153c72395c7d62efac425325b4c4c646e1fd3f
diff --git a/applications/plugins/swd_probe/README.md b/applications/plugins/swd_probe/README.md
index e69de29bb2..df4dadcd00 100644
--- a/applications/plugins/swd_probe/README.md
+++ b/applications/plugins/swd_probe/README.md
@@ -0,0 +1,17 @@
+# ARM SWD (Single Wire Debug) Probe
+
+Modern microcontrollers have support for the two wire debug interface SWD, which makes wiring a lot simpler.
+When reverse engineering, finding these two pins is a los easier than with JTAG, where you had to wire up twice or more pins. However, finding  the two pins is still a bit of work, which gets simplified even more with this application.
+
+This application tries to detect a valid SWD response on the wires you have picked and beeps when you have found the correct pins, showing the detected ID register and, more important, the SWD pinout. It doesn't matter which two pins you choose, just pick any two from the GPIOs on the breakout header. 
+
+To achieve this, the application sends packets and scans the response on all pins and elaborates the pins within a few retries. Using some kind of bisect pattern reduces this number to a hand full of tries, yielding in a seemingly instant detection. 
+
+For the user it is as simple as a continuity tester - wire up your two test needles (or accupuncture needles), connect the obvious GND pin and probe all test pads.
+Now it depends on your bisect capabilities finding all pad combinations, how long it will take this time.
+
+https://cdn.discordapp.com/attachments/954430078882816021/1071603366741938176/20230205_022641.mp4
+
+https://cdn.discordapp.com/attachments/1071712925171056690/1072306469057347594/qFlipper_2023-02-07_01-01-24.mp4 
+
+Discussion thread: https://discord.com/channels/740930220399525928/1071712925171056690
diff --git a/applications/plugins/swd_probe/swd_probe_app.c b/applications/plugins/swd_probe/swd_probe_app.c
index 0561cbde73..02cbf8a87e 100644
--- a/applications/plugins/swd_probe/swd_probe_app.c
+++ b/applications/plugins/swd_probe/swd_probe_app.c
@@ -471,7 +471,10 @@ uint8_t swd_read_memory(AppFSM* const ctx, uint8_t ap, uint32_t address, uint32_
     ret |= swd_read_ap(ctx, ap, MEMAP_DRW, data);
 
     if(ret != 1) {
+        DBG("read from 0x%08lX failed", address);
         swd_abort(ctx);
+    } else {
+        DBG("read 0x%08lX from 0x%08lX", *data, address);
     }
     return ret;
 }
@@ -705,7 +708,9 @@ static void swd_script_log(ScriptContext* ctx, FuriLogLevel level, const char* f
         size_t pos = strlen(buffer);
         vsnprintf(&buffer[pos], sizeof(buffer) - pos - 2, format, argp);
         strcat(buffer, "\n");
-        usb_uart_tx_data(ctx->app->uart, (uint8_t*)buffer, strlen(buffer));
+        if(!usb_uart_tx_data(ctx->app->uart, (uint8_t*)buffer, strlen(buffer))) {
+            DBGS("Sending via USB failed");
+        }
     } else {
         LOG(buffer);
     }
@@ -1379,9 +1384,10 @@ static bool swd_scriptfunc_mem_write(ScriptContext* ctx) {
 
         furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
         access_ok = swd_write_memory(ctx->app, ctx->selected_ap, address, data) == 1;
-        furi_mutex_release(ctx->app->swd_mutex);
         access_ok |= ctx->errors_ignore;
         swd_read_memory(ctx->app, ctx->selected_ap, address, &data);
+        furi_mutex_release(ctx->app->swd_mutex);
+
         DBG("read %08lX from %08lX", data, address);
 
         if(!access_ok) {
@@ -1406,6 +1412,60 @@ static bool swd_scriptfunc_mem_write(ScriptContext* ctx) {
     return success;
 }
 
+static bool swd_scriptfunc_mem_read(ScriptContext* ctx) {
+    uint32_t address = 0;
+    bool success = true;
+
+    /* get file */
+    if(!swd_script_skip_whitespace(ctx)) {
+        swd_script_log(ctx, FuriLogLevelError, "missing whitespace");
+        return false;
+    }
+
+    /* get address */
+    if(!swd_script_get_number(ctx, &address)) {
+        swd_script_log(ctx, FuriLogLevelError, "failed to parse address");
+        return false;
+    }
+
+    DBG("read from %08lX", address);
+
+    uint32_t data = 0;
+    bool access_ok = false;
+    for(uint32_t tries = 0; tries < ctx->max_tries; tries++) {
+        if(ctx->abort) {
+            DBGS("aborting");
+            break;
+        }
+
+        furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+        access_ok = swd_read_memory(ctx->app, ctx->selected_ap, address, &data) == 1;
+        furi_mutex_release(ctx->app->swd_mutex);
+
+        if(!access_ok) {
+            swd_script_log(ctx, FuriLogLevelError, "Failed to read from %08lX", address);
+            snprintf(
+                ctx->app->state_string,
+                sizeof(ctx->app->state_string),
+                "Failed read 0x%08lX",
+                address);
+            swd_script_gui_refresh(ctx);
+        } else {
+            swd_script_log(ctx, FuriLogLevelDefault, "%08lX", data);
+            break;
+        }
+    }
+
+    if(!access_ok) {
+        notification_message_block(ctx->app->notification, &seq_error);
+        success = false;
+    }
+
+    swd_script_seek_newline(ctx);
+
+    return success;
+}
+
 static bool swd_scriptfunc_mem_ldmst(ScriptContext* ctx) {
     uint32_t address = 0;
     uint32_t data = 0;
@@ -1633,6 +1693,275 @@ static bool swd_scriptfunc_ap_read(ScriptContext* ctx) {
     return success;
 }
 
+static bool swd_scriptfunc_core_halt(ScriptContext* ctx) {
+    bool succ = false;
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+    uint32_t reg_dhcsr = SCS_DHCSR_KEY | SCS_DHCSR_C_HALT | SCS_DHCSR_C_DEBUGEN;
+
+    succ = swd_write_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, reg_dhcsr) == 1;
+
+    if(!succ) {
+        swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed");
+    } else {
+        swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &reg_dhcsr);
+
+        if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) {
+            swd_script_log(ctx, FuriLogLevelError, "Core did not halt");
+            succ = false;
+        } else {
+            swd_script_log(ctx, FuriLogLevelDefault, "Core halted");
+        }
+    }
+
+    furi_mutex_release(ctx->app->swd_mutex);
+    swd_script_seek_newline(ctx);
+
+    return succ;
+}
+
+static bool swd_scriptfunc_core_continue(ScriptContext* ctx) {
+    bool succ = false;
+    uint32_t data = 0;
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+    succ = swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &data) == 1;
+
+    if(!(data & SCS_DHCSR_S_HALT)) {
+        swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state");
+        succ = false;
+    } else {
+        succ = swd_write_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, SCS_DHCSR_KEY) == 1;
+        furi_mutex_release(ctx->app->swd_mutex);
+    }
+
+    if(!succ) {
+        swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed");
+    } else {
+        swd_script_log(ctx, FuriLogLevelDefault, "Core continued");
+    }
+
+    swd_script_seek_newline(ctx);
+
+    return succ;
+}
+
+static bool swd_scriptfunc_core_step(ScriptContext* ctx) {
+    bool succ = false;
+    uint32_t data = 0;
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+    succ = swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &data) == 1;
+
+    if(!(data & SCS_DHCSR_S_HALT)) {
+        swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state");
+        succ = false;
+    } else {
+        succ = swd_write_memory(
+                   ctx->app,
+                   ctx->selected_ap,
+                   SCS_DHCSR,
+                   SCS_DHCSR_KEY | SCS_DHCSR_C_STEP | SCS_DHCSR_C_MASKINTS |
+                       SCS_DHCSR_C_DEBUGEN) == 1;
+    }
+    furi_mutex_release(ctx->app->swd_mutex);
+
+    if(!succ) {
+        swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed");
+    } else {
+        swd_script_log(ctx, FuriLogLevelDefault, "Core stepped");
+    }
+
+    swd_script_seek_newline(ctx);
+
+    return succ;
+}
+
+static struct cpu_regs_type {
+    uint8_t regsel;
+    const char* desc;
+} cpu_regs[] = {
+    {0x00, "R00"},    {0x01, "R01"},    {0x02, "R02"},    {0x03, "R03"},    {0x04, "R04"},
+    {0x05, "R05"},    {0x06, "R06"},    {0x07, "R07"},    {0x08, "R08"},    {0x09, "R09"},
+    {0x0A, "R10"},    {0x0B, "R11"},    {0x0C, "R12"},    {0x0D, "SP/R13"}, {0x0E, "LR/R14"},
+    {0x0F, "PC/R15"}, {0x10, "xPSR"},   {0x11, "MSP"},    {0x12, "PSP"},    {0x14, "Flags"},
+    {0x21, "FPCSR"},  {0x40, "FP S00"}, {0x41, "FP S01"}, {0x42, "FP S02"}, {0x43, "FP S03"},
+    {0x44, "FP S04"}, {0x45, "FP S05"}, {0x46, "FP S06"}, {0x47, "FP S07"}, {0x48, "FP S08"},
+    {0x49, "FP S09"}, {0x4A, "FP S10"}, {0x4B, "FP S11"}, {0x4C, "FP S12"}, {0x4D, "FP S13"},
+    {0x4E, "FP S14"}, {0x4F, "FP S15"}, {0x50, "FP S16"}, {0x51, "FP S17"}, {0x52, "FP S18"},
+    {0x53, "FP S19"}, {0x54, "FP S20"}, {0x55, "FP S21"}, {0x56, "FP S22"}, {0x57, "FP S23"},
+    {0x58, "FP S24"}, {0x59, "FP S25"}, {0x5A, "FP S26"}, {0x5B, "FP S27"}, {0x5C, "FP S28"},
+    {0x5D, "FP S29"}, {0x5E, "FP S30"}, {0x5F, "FP S31"}};
+
+static bool swd_scriptfunc_core_regs(ScriptContext* ctx) {
+    bool succ = false;
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+
+    uint32_t reg_dhcsr = 0;
+    uint32_t reg_cpacr = 0;
+    swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &reg_dhcsr);
+    swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPACR, &reg_cpacr);
+
+    /* when FPU is enabled/available, CP10 and CP11 are implemented */
+    bool has_fpu = ((reg_cpacr >> 20) & 0x0F) != 0;
+
+    if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) {
+        swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state");
+        succ = false;
+    } else {
+        for(size_t pos = 0; pos < COUNT(cpu_regs); pos++) {
+            if(!has_fpu && (cpu_regs[pos].regsel >= 0x20)) {
+                continue;
+            }
+            uint32_t core_data = 0;
+            succ =
+                swd_write_memory(
+                    ctx->app, ctx->selected_ap, SCS_DCRSR, SCS_DCRSR_RD | cpu_regs[pos].regsel) ==
+                1;
+            succ &= swd_read_memory(ctx->app, ctx->selected_ap, SCS_DCRDR, &core_data) == 1;
+
+            if(!succ) {
+                swd_script_log(ctx, FuriLogLevelDefault, "%08s ----------", cpu_regs[pos].desc);
+            } else {
+                swd_script_log(
+                    ctx, FuriLogLevelDefault, "%06s 0x%08X", cpu_regs[pos].desc, core_data);
+            }
+        }
+    }
+    furi_mutex_release(ctx->app->swd_mutex);
+
+    swd_script_seek_newline(ctx);
+
+    return true;
+}
+
+static bool swd_scriptfunc_core_reg_get(ScriptContext* ctx) {
+    uint32_t core_reg = 0;
+    uint32_t core_data = 0;
+    bool succ = false;
+
+    if(!swd_script_skip_whitespace(ctx)) {
+        swd_script_log(ctx, FuriLogLevelError, "missing whitespace");
+        return false;
+    }
+
+    if(!swd_script_get_number(ctx, &core_reg)) {
+        swd_script_log(ctx, FuriLogLevelError, "failed to parse register");
+        return false;
+    }
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+    uint32_t reg_dhcsr = 0;
+    uint32_t reg_cpacr = 0;
+    swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &reg_dhcsr);
+    swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPACR, &reg_cpacr);
+
+    /* when FPU is enabled/available, CP10 and CP11 are implemented */
+    bool has_fpu = ((reg_cpacr >> 20) & 0x0F) != 0;
+
+    if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) {
+        swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state");
+        succ = false;
+    } else {
+        if(!has_fpu && (core_reg >= 0x20)) {
+            swd_script_log(ctx, FuriLogLevelError, "Core has no FP extensions");
+            succ = false;
+        } else {
+            succ = swd_write_memory(
+                       ctx->app, ctx->selected_ap, SCS_DCRSR, SCS_DCRSR_RD | core_reg) == 1;
+            succ &= swd_read_memory(ctx->app, ctx->selected_ap, SCS_DCRDR, &core_data) == 1;
+            if(!succ) {
+                swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed");
+            }
+        }
+    }
+    furi_mutex_release(ctx->app->swd_mutex);
+
+    if(succ) {
+        swd_script_log(ctx, FuriLogLevelDefault, "0x%08X", core_data);
+    }
+
+    swd_script_seek_newline(ctx);
+
+    return succ;
+}
+
+static bool swd_scriptfunc_core_reg_set(ScriptContext* ctx) {
+    uint32_t core_reg = 0;
+    uint32_t core_data = 0;
+    bool succ = false;
+
+    if(!swd_script_skip_whitespace(ctx)) {
+        swd_script_log(ctx, FuriLogLevelError, "missing whitespace");
+        return false;
+    }
+
+    if(!swd_script_get_number(ctx, &core_reg)) {
+        swd_script_log(ctx, FuriLogLevelError, "failed to parse register");
+        return false;
+    }
+    if(!swd_script_skip_whitespace(ctx)) {
+        swd_script_log(ctx, FuriLogLevelError, "missing whitespace");
+        return false;
+    }
+    if(!swd_script_get_number(ctx, &core_data)) {
+        swd_script_log(ctx, FuriLogLevelError, "failed to parse data");
+        return false;
+    }
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+    uint32_t reg_dhcsr = 0;
+    uint32_t reg_cpacr = 0;
+
+    swd_read_memory(ctx->app, ctx->selected_ap, SCS_DHCSR, &reg_dhcsr);
+    swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPACR, &reg_cpacr);
+
+    /* when FPU is enabled/available, CP10 and CP11 are implemented */
+    bool has_fpu = ((reg_cpacr >> 20) & 0x0F) != 0;
+
+    if(!(reg_dhcsr & SCS_DHCSR_S_HALT)) {
+        swd_script_log(ctx, FuriLogLevelError, "Core is not in debug state");
+        succ = false;
+    } else {
+        if(!has_fpu && (core_reg >= 0x20)) {
+            swd_script_log(ctx, FuriLogLevelError, "Core has no FP extensions");
+            succ = false;
+        } else {
+            succ = swd_write_memory(ctx->app, ctx->selected_ap, SCS_DCRDR, core_data) == 1;
+            succ &= swd_write_memory(
+                        ctx->app, ctx->selected_ap, SCS_DCRSR, SCS_DCRSR_WR | core_reg) == 1;
+            if(!succ) {
+                swd_script_log(ctx, FuriLogLevelError, "swd_write_memory failed");
+            }
+        }
+    }
+    furi_mutex_release(ctx->app->swd_mutex);
+
+    swd_script_seek_newline(ctx);
+
+    return succ;
+}
+
+static bool swd_scriptfunc_core_cpuid(ScriptContext* ctx) {
+    bool succ = false;
+    uint32_t reg_cpuid = 0;
+
+    furi_mutex_acquire(ctx->app->swd_mutex, FuriWaitForever);
+    succ = swd_read_memory(ctx->app, ctx->selected_ap, SCS_CPUID, &reg_cpuid) == 1;
+    furi_mutex_release(ctx->app->swd_mutex);
+
+    if(!succ) {
+        swd_script_log(ctx, FuriLogLevelError, "swd_read_memory failed");
+    } else {
+        swd_script_log(ctx, FuriLogLevelDefault, "0x%08X", reg_cpuid);
+    }
+
+    swd_script_seek_newline(ctx);
+
+    return succ;
+}
+
 static const ScriptFunctionInfo script_funcs[] = {
     {"#", &swd_scriptfunc_comment},
     {".label", &swd_scriptfunc_label},
@@ -1650,12 +1979,20 @@ static const ScriptFunctionInfo script_funcs[] = {
     {"mem_dump", &swd_scriptfunc_mem_dump},
     {"mem_ldmst", &swd_scriptfunc_mem_ldmst},
     {"mem_write", &swd_scriptfunc_mem_write},
+    {"mem_read", &swd_scriptfunc_mem_read},
     {"dp_write", &swd_scriptfunc_dp_write},
     {"dp_read", &swd_scriptfunc_dp_read},
     {"ap_scan", &swd_scriptfunc_apscan},
     {"ap_select", &swd_scriptfunc_apselect},
     {"ap_read", &swd_scriptfunc_ap_read},
-    {"ap_write", &swd_scriptfunc_ap_write}};
+    {"ap_write", &swd_scriptfunc_ap_write},
+    {"core_halt", &swd_scriptfunc_core_halt},
+    {"core_step", &swd_scriptfunc_core_step},
+    {"core_continue", &swd_scriptfunc_core_continue},
+    {"core_regs", &swd_scriptfunc_core_regs},
+    {"core_reg_get", &swd_scriptfunc_core_reg_get},
+    {"core_reg_set", &swd_scriptfunc_core_reg_set},
+    {"core_cpuid", &swd_scriptfunc_core_cpuid}};
 
 /************************** script main code **************************/
 
@@ -2487,7 +2824,6 @@ static void swd_main_loop(AppFSM* ctx) {
     }
 
     case ModePageDPRegs:
-    case ModePageDPID:
     case ModePageAPID: {
         furi_mutex_acquire(ctx->swd_mutex, FuriWaitForever);
         /* set debug enable request */
@@ -2532,6 +2868,7 @@ static void swd_main_loop(AppFSM* ctx) {
         break;
     }
 
+    case ModePageDPID:
     case ModePageCoresight:
         furi_delay_ms(50);
         break;
diff --git a/applications/plugins/swd_probe/swd_probe_app.h b/applications/plugins/swd_probe/swd_probe_app.h
index 152088925c..ff7154cafd 100644
--- a/applications/plugins/swd_probe/swd_probe_app.h
+++ b/applications/plugins/swd_probe/swd_probe_app.h
@@ -88,6 +88,21 @@ typedef enum {
 #define AP_IDR 0xFC
 #define AP_BASE 0xF8
 
+#define SCS_CPUID 0xE000ED00u
+#define SCS_CPACR 0xE000ED88u
+#define SCS_DHCSR 0xE000EDF0u
+#define SCS_DHCSR_S_HALT (1u << 17)
+#define SCS_DHCSR_C_MASKINTS (1u << 3)
+#define SCS_DHCSR_C_STEP (1u << 2)
+#define SCS_DHCSR_C_HALT (1u << 1)
+#define SCS_DHCSR_C_DEBUGEN (1u << 0)
+#define SCS_DHCSR_KEY 0xA05F0000u
+#define SCS_DCRSR 0xE000EDF4u
+#define SCS_DCRSR_RD 0x00000000u
+#define SCS_DCRSR_WR 0x00010000u
+#define SCS_DCRDR 0xE000EDF8u
+#define SCS_DEMCR 0xE000EDFCu
+
 typedef enum { KeyNone, KeyUp, KeyRight, KeyDown, KeyLeft, KeyOK } KeyCode;
 
 typedef enum {
diff --git a/applications/plugins/swd_probe/usb_uart.c b/applications/plugins/swd_probe/usb_uart.c
index 76841cf11d..9674541ec7 100644
--- a/applications/plugins/swd_probe/usb_uart.c
+++ b/applications/plugins/swd_probe/usb_uart.c
@@ -76,7 +76,7 @@ static void usb_uart_vcp_deinit(UsbUart* usb_uart, uint8_t vcp_ch) {
     }
 }
 
-void usb_uart_tx_data(UsbUart* usb_uart, uint8_t* data, size_t length) {
+bool usb_uart_tx_data(UsbUart* usb_uart, uint8_t* data, size_t length) {
     uint32_t pos = 0;
     while(pos < length) {
         size_t pkt_size = length - pos;
@@ -85,14 +85,19 @@ void usb_uart_tx_data(UsbUart* usb_uart, uint8_t* data, size_t length) {
             pkt_size = USB_CDC_PKT_LEN;
         }
 
-        if(furi_semaphore_acquire(usb_uart->tx_sem, 100) == FuriStatusOk) {
-            furi_check(furi_mutex_acquire(usb_uart->usb_mutex, FuriWaitForever) == FuriStatusOk);
-            furi_hal_cdc_send(usb_uart->cfg.vcp_ch, &data[pos], pkt_size);
-            furi_check(furi_mutex_release(usb_uart->usb_mutex) == FuriStatusOk);
-            usb_uart->st.tx_cnt += pkt_size;
-            pos += pkt_size;
+        if(furi_semaphore_acquire(usb_uart->tx_sem, 100) != FuriStatusOk) {
+            return false;
         }
+        if(furi_mutex_acquire(usb_uart->usb_mutex, 100) != FuriStatusOk) {
+            furi_semaphore_release(usb_uart->tx_sem);
+            return false;
+        }
+        furi_hal_cdc_send(usb_uart->cfg.vcp_ch, &data[pos], pkt_size);
+        furi_mutex_release(usb_uart->usb_mutex);
+        usb_uart->st.tx_cnt += pkt_size;
+        pos += pkt_size;
     }
+    return true;
 }
 
 static int32_t usb_uart_worker(void* context) {
@@ -118,10 +123,11 @@ static int32_t usb_uart_worker(void* context) {
         }
 
         if(events & WorkerEvtCdcRx) {
-            furi_check(furi_mutex_acquire(usb_uart->usb_mutex, FuriWaitForever) == FuriStatusOk);
-            size_t len =
-                furi_hal_cdc_receive(usb_uart->cfg.vcp_ch, &data[remain], USB_CDC_PKT_LEN);
-            furi_check(furi_mutex_release(usb_uart->usb_mutex) == FuriStatusOk);
+            size_t len = 0;
+            if(furi_mutex_acquire(usb_uart->usb_mutex, 100) == FuriStatusOk) {
+                len = furi_hal_cdc_receive(usb_uart->cfg.vcp_ch, &data[remain], USB_CDC_PKT_LEN);
+                furi_mutex_release(usb_uart->usb_mutex);
+            }
 
             if(len > 0) {
                 usb_uart->st.rx_cnt += len;
diff --git a/applications/plugins/swd_probe/usb_uart.h b/applications/plugins/swd_probe/usb_uart.h
index a82f36a056..325a4db98e 100644
--- a/applications/plugins/swd_probe/usb_uart.h
+++ b/applications/plugins/swd_probe/usb_uart.h
@@ -26,4 +26,4 @@ void usb_uart_get_config(UsbUart* usb_uart, UsbUartConfig* cfg);
 
 void usb_uart_get_state(UsbUart* usb_uart, UsbUartState* st);
 
-void usb_uart_tx_data(UsbUart* usb_uart, uint8_t* data, size_t length);
+bool usb_uart_tx_data(UsbUart* usb_uart, uint8_t* data, size_t length);
diff --git a/applications/plugins/tetris_game/tetris_game.c b/applications/plugins/tetris_game/tetris_game.c
index 0b813f26ae..a569f46d42 100644
--- a/applications/plugins/tetris_game/tetris_game.c
+++ b/applications/plugins/tetris_game/tetris_game.c
@@ -71,6 +71,7 @@ typedef struct {
     uint16_t fallSpeed;
     GameState gameState;
     FuriTimer* timer;
+    FuriMutex* mutex;
 } TetrisState;
 
 typedef enum {
@@ -127,11 +128,9 @@ static void tetris_game_draw_playfield(Canvas* const canvas, const TetrisState*
 }
 
 static void tetris_game_render_callback(Canvas* const canvas, void* ctx) {
-    const TetrisState* tetris_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(tetris_state == NULL) {
-        FURI_LOG_E("TetrisGame", "it null");
-        return;
-    }
+    furi_assert(ctx);
+    const TetrisState* tetris_state = ctx;
+    furi_mutex_acquire(tetris_state->mutex, FuriWaitForever);
 
     tetris_game_draw_border(canvas);
     tetris_game_draw_playfield(canvas, tetris_state);
@@ -159,7 +158,7 @@ static void tetris_game_render_callback(Canvas* const canvas, void* ctx) {
         canvas_set_font(canvas, FontSecondary);
         canvas_draw_str_aligned(canvas, 32, 73, AlignCenter, AlignBottom, buffer);
     }
-    release_mutex((ValueMutex*)ctx, tetris_state);
+    furi_mutex_release(tetris_state->mutex);
 }
 
 static void tetris_game_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -358,8 +357,8 @@ int32_t tetris_game_app() {
 
     TetrisState* tetris_state = malloc(sizeof(TetrisState));
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, tetris_state, sizeof(TetrisState))) {
+    tetris_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!tetris_state->mutex) {
         FURI_LOG_E("TetrisGame", "cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(tetris_state);
@@ -376,7 +375,7 @@ int32_t tetris_game_app() {
 
     ViewPort* view_port = view_port_alloc();
     view_port_set_orientation(view_port, ViewPortOrientationVertical);
-    view_port_draw_callback_set(view_port, tetris_game_render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, tetris_game_render_callback, tetris_state);
     view_port_input_callback_set(view_port, tetris_game_input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -399,7 +398,7 @@ int32_t tetris_game_app() {
         // This 10U implicitly sets the game loop speed. downRepeatCounter relies on this value
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 10U);
 
-        TetrisState* tetris_state = (TetrisState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(tetris_state->mutex, FuriWaitForever);
 
         memcpy(newPiece, &tetris_state->currPiece, sizeof(tetris_state->currPiece));
         bool wasDownMove = false;
@@ -466,7 +465,7 @@ int32_t tetris_game_app() {
         tetris_game_process_step(tetris_state, newPiece, wasDownMove);
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, tetris_state);
+        furi_mutex_release(tetris_state->mutex);
     }
 
     furi_timer_free(tetris_state->timer);
@@ -475,7 +474,7 @@ int32_t tetris_game_app() {
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(tetris_state->mutex);
     vTaskPrioritySet(timer_task, origTimerPrio);
     free(newPiece);
     free(tetris_state);
diff --git a/applications/plugins/tictactoe_game/tictactoe_game.c b/applications/plugins/tictactoe_game/tictactoe_game.c
index ec82192a85..e617e7c18d 100644
--- a/applications/plugins/tictactoe_game/tictactoe_game.c
+++ b/applications/plugins/tictactoe_game/tictactoe_game.c
@@ -10,6 +10,7 @@
 typedef enum { EventTypeTick, EventTypeKey } EventType;
 
 typedef struct {
+    FuriMutex* mutex;
     FuriTimer* timer;
     uint8_t selBoxX;
     uint8_t selBoxY;
@@ -173,10 +174,9 @@ static void tictactoe_state_init(TicTacToeState* tictactoe_state) {
 }
 
 static void tictactoe_draw_callback(Canvas* const canvas, void* ctx) {
-    TicTacToeState* ticst = acquire_mutex((ValueMutex*)ctx, 25);
-    if(ticst == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    TicTacToeState* ticst = ctx;
+    furi_mutex_acquire(ticst->mutex, FuriWaitForever);
 
     if(ticst->selX > 3) {
         ticst->selX = 3;
@@ -285,7 +285,7 @@ static void tictactoe_draw_callback(Canvas* const canvas, void* ctx) {
 
     tictactoe_draw(canvas, ticst);
 
-    release_mutex((ValueMutex*)ctx, ticst);
+    furi_mutex_release(ticst->mutex);
 }
 
 static void tictactoe_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -308,8 +308,9 @@ int32_t tictactoe_game_app(void* p) {
 
     TicTacToeState* tictactoe_state = malloc(sizeof(TicTacToeState));
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, tictactoe_state, sizeof(TicTacToeState))) {
+    tictactoe_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+
+    if(!tictactoe_state->mutex) {
         FURI_LOG_E(TAG, "Cannot create mutex\r\n");
         furi_message_queue_free(event_queue);
         free(tictactoe_state);
@@ -318,7 +319,7 @@ int32_t tictactoe_game_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, tictactoe_draw_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, tictactoe_draw_callback, tictactoe_state);
     view_port_input_callback_set(view_port, tictactoe_input_callback, event_queue);
 
     tictactoe_state->timer =
@@ -337,7 +338,7 @@ int32_t tictactoe_game_app(void* p) {
     GameEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        TicTacToeState* tictactoe_state = (TicTacToeState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(tictactoe_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             // Key events
@@ -370,7 +371,7 @@ int32_t tictactoe_game_app(void* p) {
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, tictactoe_state);
+        furi_mutex_release(tictactoe_state->mutex);
     }
 
     furi_timer_free(tictactoe_state->timer);
@@ -379,7 +380,7 @@ int32_t tictactoe_game_app(void* p) {
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(tictactoe_state->mutex);
     free(tictactoe_state);
 
     return 0;
diff --git a/applications/plugins/totp/totp_app.c b/applications/plugins/totp/totp_app.c
index f791e99de6..322acd36c6 100644
--- a/applications/plugins/totp/totp_app.c
+++ b/applications/plugins/totp/totp_app.c
@@ -23,12 +23,14 @@
 #define IDLE_TIMEOUT 60000
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
+    furi_assert(ctx);
+    PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
     if(plugin_state != NULL) {
         totp_scene_director_render(canvas, plugin_state);
     }
 
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -137,8 +139,8 @@ int32_t totp_app() {
         return 254;
     }
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         FURI_LOG_E(LOGGING_TAG, "Cannot create mutex\r\n");
         totp_plugin_state_free(plugin_state);
         return 255;
@@ -157,7 +159,7 @@ int32_t totp_app() {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -169,7 +171,7 @@ int32_t totp_app() {
     while(processing) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
 
-        PluginState* plugin_state_m = acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
         if(event_status == FuriStatusOk) {
             if(event.type == EventTypeKey) {
@@ -179,16 +181,16 @@ int32_t totp_app() {
             if(event.type == EventForceCloseApp) {
                 processing = false;
             } else {
-                processing = totp_scene_director_handle_event(&event, plugin_state_m);
+                processing = totp_scene_director_handle_event(&event, plugin_state);
             }
         } else if(
-            plugin_state_m->pin_set && plugin_state_m->current_scene != TotpSceneAuthentication &&
+            plugin_state->pin_set && plugin_state->current_scene != TotpSceneAuthentication &&
             furi_get_tick() - last_user_interaction_time > IDLE_TIMEOUT) {
-            totp_scene_director_activate_scene(plugin_state_m, TotpSceneAuthentication, NULL);
+            totp_scene_director_activate_scene(plugin_state, TotpSceneAuthentication, NULL);
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state_m);
+        furi_mutex_release(plugin_state->mutex);
     }
 
     totp_cli_unregister_command_handler(cli_context);
@@ -199,7 +201,7 @@ int32_t totp_app() {
     gui_remove_view_port(plugin_state->gui, view_port);
     view_port_free(view_port);
     furi_message_queue_free(event_queue);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(plugin_state->mutex);
     totp_plugin_state_free(plugin_state);
     return 0;
 }
diff --git a/applications/plugins/totp/types/plugin_state.h b/applications/plugins/totp/types/plugin_state.h
index 0aad2e125c..b5e78d0cf2 100644
--- a/applications/plugins/totp/types/plugin_state.h
+++ b/applications/plugins/totp/types/plugin_state.h
@@ -87,4 +87,5 @@ typedef struct {
      * @brief Notification method
      */
     NotificationMethod notification_method;
+    FuriMutex* mutex;
 } PluginState;
diff --git a/applications/plugins/totp/workers/type_code/type_code.c b/applications/plugins/totp/workers/type_code/type_code.c
index 3eb59047a8..06fe7897e0 100644
--- a/applications/plugins/totp/workers/type_code/type_code.c
+++ b/applications/plugins/totp/workers/type_code/type_code.c
@@ -57,8 +57,10 @@ static void totp_type_code_worker_type_code(TotpTypeCodeWorkerContext* context)
 }
 
 static int32_t totp_type_code_worker_callback(void* context) {
-    ValueMutex context_mutex;
-    if(!init_mutex(&context_mutex, context, sizeof(TotpTypeCodeWorkerContext))) {
+    furi_assert(context);
+    TotpTypeCodeWorkerContext* ctxx = context;
+    ctxx->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!ctxx->mutex) {
         return 251;
     }
 
@@ -70,15 +72,16 @@ static int32_t totp_type_code_worker_callback(void* context) {
         furi_check((flags & FuriFlagError) == 0); //-V562
         if(flags & TotpTypeCodeWorkerEventStop) break;
 
-        TotpTypeCodeWorkerContext* h_context = acquire_mutex_block(&context_mutex);
+        TotpTypeCodeWorkerContext* h_context = context;
+        furi_mutex_acquire(ctxx->mutex, FuriWaitForever);
         if(flags & TotpTypeCodeWorkerEventType) {
             totp_type_code_worker_type_code(h_context);
         }
 
-        release_mutex(&context_mutex, h_context);
+        furi_mutex_release(ctxx->mutex);
     }
 
-    delete_mutex(&context_mutex);
+    furi_mutex_free(ctxx->mutex);
 
     return 0;
 }
diff --git a/applications/plugins/totp/workers/type_code/type_code.h b/applications/plugins/totp/workers/type_code/type_code.h
index 27f2e02d4c..b696420bc6 100644
--- a/applications/plugins/totp/workers/type_code/type_code.h
+++ b/applications/plugins/totp/workers/type_code/type_code.h
@@ -12,6 +12,7 @@ typedef struct {
     FuriThread* thread;
     FuriMutex* string_sync;
     FuriHalUsbInterface* usb_mode_prev;
+    FuriMutex* mutex;
 } TotpTypeCodeWorkerContext;
 
 enum TotpTypeCodeWorkerEvents {
diff --git a/applications/plugins/unitemp/README.md b/applications/plugins/unitemp/README.md
index 436f3600ec..2da78d2bdd 100644
--- a/applications/plugins/unitemp/README.md
+++ b/applications/plugins/unitemp/README.md
@@ -13,7 +13,7 @@
 3) Open application on your Flipper: `Applications->GPIO->Temp sensors reader`  
 Note: If you get the message "API version mismatch" after updating the firmware, download and install Unitemp again
 ## Need help? Discussions?
-Join the discussion, ask a question or just send a photo of the flipper with sensors to [Discord](https://discord.com/channels/740930220399525928/1056727938747351060)
+Join the discussion, ask a question or just send a photo of the flipper with sensors to [Discord](https://discord.com/channels/740930220399525928/1056727938747351060). [Invite link](https://discord.com/invite/flipper)
 ## Gratitudes
 Thanks to [@Svaarich](https://github.com/Svaarich) for the UI design and to the Unleashed firmware community for sensors testing and feedbacks.
 
@@ -21,4 +21,4 @@ Thanks to [@Svaarich](https://github.com/Svaarich) for the UI design and to the
 ![image](https://user-images.githubusercontent.com/10090793/210120132-7ddbc937-0a6b-4472-bd1c-7fbc3ecdf2ad.png)
 ![image](https://user-images.githubusercontent.com/10090793/210120135-12fc5810-77ff-49db-b799-e9479e1f57a7.png)
 ![image](https://user-images.githubusercontent.com/10090793/210120143-a2bae3ce-4190-421f-8c4f-c7c744903bd6.png)
-![image](https://user-images.githubusercontent.com/10090793/215224085-8099408e-b3de-4a0c-854e-fe4e4faa8ea3.png)
\ No newline at end of file
+![image](https://user-images.githubusercontent.com/10090793/215224085-8099408e-b3de-4a0c-854e-fe4e4faa8ea3.png)
diff --git a/applications/plugins/unitemp/Sensors.c b/applications/plugins/unitemp/Sensors.c
index d9304ab323..30419a9296 100644
--- a/applications/plugins/unitemp/Sensors.c
+++ b/applications/plugins/unitemp/Sensors.c
@@ -149,8 +149,7 @@ uint8_t unitemp_gpio_getAviablePortsCount(const Interface* interface, const GPIO
     for(uint8_t i = 0; i < GPIO_ITEMS; i++) {
         //Проверка для one wire
         if(interface == &ONE_WIRE) {
-            if(((gpio_interfaces_list[i] == NULL || gpio_interfaces_list[i] == &ONE_WIRE) &&
-                (i != 12)) || //Почему-то не работает на 17 порте
+            if(((gpio_interfaces_list[i] == NULL || gpio_interfaces_list[i] == &ONE_WIRE)) ||
                (unitemp_gpio_getFromIndex(i) == extraport)) {
                 aviable_ports_count++;
             }
@@ -208,9 +207,7 @@ const GPIO*
     for(uint8_t i = 0; i < GPIO_ITEMS; i++) {
         //Проверка для one wire
         if(interface == &ONE_WIRE) {
-            //Почему-то не работает на 17 порте
-            if(((gpio_interfaces_list[i] == NULL || gpio_interfaces_list[i] == &ONE_WIRE) &&
-                (i != 12)) || //Почему-то не работает на 17 порте
+            if(((gpio_interfaces_list[i] == NULL || gpio_interfaces_list[i] == &ONE_WIRE)) ||
                (unitemp_gpio_getFromIndex(i) == extraport)) {
                 if(aviable_index == index) {
                     return unitemp_gpio_getFromIndex(i);
diff --git a/applications/plugins/unitemp/interfaces/OneWireSensor.c b/applications/plugins/unitemp/interfaces/OneWireSensor.c
index f4f3ebcdc6..377eb0d08c 100644
--- a/applications/plugins/unitemp/interfaces/OneWireSensor.c
+++ b/applications/plugins/unitemp/interfaces/OneWireSensor.c
@@ -20,7 +20,6 @@
 #include "OneWireSensor.h"
 #include <furi.h>
 #include <furi_hal.h>
-#include <one_wire/one_wire_host.h>
 
 const SensorType Dallas = {
     .typename = "Dallas",
@@ -37,8 +36,6 @@ const SensorType Dallas = {
 // Переменные для хранения промежуточного результата сканирования шины
 // найденный восьмибайтовый адрес
 static uint8_t onewire_enum[8] = {0};
-// последний нулевой бит, где была неоднозначность (нумеруя с единицы)
-static uint8_t onewire_enum_fork_bit = 65;
 
 OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio) {
     if(gpio == NULL) {
@@ -55,9 +52,11 @@ OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio) {
     }
 
     OneWireBus* bus = malloc(sizeof(OneWireBus));
+
     bus->device_count = 0;
     bus->gpio = gpio;
     bus->powerMode = PWR_PASSIVE;
+
     UNITEMP_DEBUG("one wire bus (port %d) allocated", gpio->num);
 
     return bus;
@@ -69,6 +68,8 @@ bool unitemp_onewire_bus_init(OneWireBus* bus) {
     //Выход если шина уже была инициализирована
     if(bus->device_count > 1) return true;
 
+    bus->host = onewire_host_alloc(bus->gpio->pin);
+
     unitemp_gpio_lock(bus->gpio, &ONE_WIRE);
     //Высокий уровень по умолчанию
     furi_hal_gpio_write(bus->gpio->pin, true);
@@ -81,6 +82,7 @@ bool unitemp_onewire_bus_init(OneWireBus* bus) {
 
     return true;
 }
+
 bool unitemp_onewire_bus_deinit(OneWireBus* bus) {
     UNITEMP_DEBUG("devices on wire %d: %d", bus->gpio->num, bus->device_count);
     bus->device_count--;
@@ -100,84 +102,34 @@ bool unitemp_onewire_bus_deinit(OneWireBus* bus) {
         return false;
     }
 }
-bool unitemp_onewire_bus_start(OneWireBus* bus) {
-    furi_hal_gpio_write(bus->gpio->pin, false);
-    furi_delay_us(500);
-
-    furi_hal_gpio_write(bus->gpio->pin, true);
-
-    //Ожидание подъёма шины
-    uint32_t t = furi_get_tick();
-    while(!furi_hal_gpio_read(bus->gpio->pin)) {
-        //Выход если шина не поднялась
-        if(furi_get_tick() - t > 10) return false;
-    }
-
-    furi_delay_us(100);
-    bool status = !furi_hal_gpio_read(bus->gpio->pin);
-    furi_delay_us(400);
-    return status;
+inline bool unitemp_onewire_bus_start(OneWireBus* bus) {
+    return onewire_host_reset(bus->host);
 }
 
-void unitemp_onewire_bus_send_bit(OneWireBus* bus, bool state) {
-    //Необходимо для стабильной работы при пассивном питании
-    if(bus->powerMode == PWR_PASSIVE) furi_delay_us(100);
-
-    if(state) {
-        // write 1
-        furi_hal_gpio_write(bus->gpio->pin, false);
-        furi_delay_us(1);
-        furi_hal_gpio_write(bus->gpio->pin, true);
-        furi_delay_us(90);
-    } else {
-        furi_hal_gpio_write(bus->gpio->pin, false);
-        furi_delay_us(90);
-        furi_hal_gpio_write(bus->gpio->pin, true);
-        //Ожидание подъёма шины
-        uint32_t t = furi_get_tick();
-        while(!furi_hal_gpio_read(bus->gpio->pin)) {
-            //Выход если шина не поднялась
-            if(furi_get_tick() - t > 10) return;
-        }
-    }
+inline void unitemp_onewire_bus_send_bit(OneWireBus* bus, bool state) {
+    onewire_host_write_bit(bus->host, state);
 }
 
-void unitemp_onewire_bus_send_byte(OneWireBus* bus, uint8_t data) {
-    for(int i = 0; i < 8; i++) {
-        unitemp_onewire_bus_send_bit(bus, (data & (1 << i)) != 0);
-    }
+inline void unitemp_onewire_bus_send_byte(OneWireBus* bus, uint8_t data) {
+    onewire_host_write(bus->host, data);
 }
 
 void unitemp_onewire_bus_send_byteArray(OneWireBus* bus, uint8_t* data, uint8_t len) {
     for(uint8_t i = 0; i < len; i++) {
-        unitemp_onewire_bus_send_byte(bus, data[i]);
+        onewire_host_write(bus->host, data[i]);
     }
 }
 
-bool unitemp_onewire_bus_read_bit(OneWireBus* bus) {
-    furi_delay_ms(1);
-    furi_hal_gpio_write(bus->gpio->pin, false);
-    furi_delay_us(2); // Длительность низкого уровня, минимум 1 мкс
-    furi_hal_gpio_write(bus->gpio->pin, true);
-    furi_delay_us(8); // Пауза до момента сэмплирования, всего не более 15 мкс
-    bool r = furi_hal_gpio_read(bus->gpio->pin);
-    furi_delay_us(80); // Ожидание до следующего тайм-слота, минимум 60 мкс с начала низкого уровня
-    return r;
+inline bool unitemp_onewire_bus_read_bit(OneWireBus* bus) {
+    return onewire_host_read_bit(bus->host);
 }
 
-uint8_t unitemp_onewire_bus_read_byte(OneWireBus* bus) {
-    uint8_t r = 0;
-    for(uint8_t p = 8; p; p--) {
-        r >>= 1;
-        if(unitemp_onewire_bus_read_bit(bus)) r |= 0x80;
-    }
-    return r;
+inline uint8_t unitemp_onewire_bus_read_byte(OneWireBus* bus) {
+    return onewire_host_read(bus->host);
 }
 
 void unitemp_onewire_bus_read_byteArray(OneWireBus* bus, uint8_t* data, uint8_t len) {
-    for(uint8_t i = 0; i < len; i++) {
-        data[i] = unitemp_onewire_bus_read_byte(bus);
-    }
+    onewire_host_read_bytes(bus->host, data, len);
 }
 
 static uint8_t onewire_CRC_update(uint8_t crc, uint8_t b) {
@@ -222,77 +174,16 @@ bool unitemp_onewire_sensor_readID(OneWireSensor* instance) {
     return true;
 }
 
-void unitemp_onewire_bus_enum_init(void) {
-    for(uint8_t p = 0; p < 8; p++) {
-        onewire_enum[p] = 0;
-    }
-    onewire_enum_fork_bit = 65; // правее правого
+void unitemp_onewire_bus_enum_init(OneWireBus* bus) {
+    onewire_host_reset_search(bus->host);
 }
 
 uint8_t* unitemp_onewire_bus_enum_next(OneWireBus* bus) {
-    furi_delay_ms(10);
-    if(!onewire_enum_fork_bit) { // Если на предыдущем шаге уже не было разногласий
-        UNITEMP_DEBUG("All devices on wire %d is found", unitemp_gpio_toInt(bus->gpio));
-        return 0; // то просто выходим ничего не возвращая
-    }
-    if(!unitemp_onewire_bus_start(bus)) {
-        UNITEMP_DEBUG("Wire %d is empty", unitemp_gpio_toInt(bus->gpio));
-        return 0;
-    }
-    uint8_t bp = 8;
-    uint8_t* pprev = &onewire_enum[0];
-    uint8_t prev = *pprev;
-    uint8_t next = 0;
-
-    uint8_t p = 1;
-    unitemp_onewire_bus_send_byte(bus, 0xF0);
-    uint8_t newfork = 0;
-    for(;;) {
-        uint8_t not0 = unitemp_onewire_bus_read_bit(bus);
-        uint8_t not1 = unitemp_onewire_bus_read_bit(bus);
-        if(!not0) { // Если присутствует в адресах бит ноль
-            if(!not1) { // Но также присустствует бит 1 (вилка)
-                if(p <
-                   onewire_enum_fork_bit) { // Если мы левее прошлого правого конфликтного бита,
-                    if(prev & 1) {
-                        next |= 0x80; // то копируем значение бита из прошлого прохода
-                    } else {
-                        newfork = p; // если ноль, то запомним конфликтное место
-                    }
-                } else if(p == onewire_enum_fork_bit) {
-                    next |=
-                        0x80; // если на этом месте в прошлый раз был правый конфликт с нулём, выведем 1
-                } else {
-                    newfork = p; // правее - передаём ноль и запоминаем конфликтное место
-                }
-            } // в противном случае идём, выбирая ноль в адресе
-        } else {
-            if(!not1) { // Присутствует единица
-                next |= 0x80;
-            } else { // Нет ни нулей ни единиц - ошибочная ситуация
-
-                UNITEMP_DEBUG("Wrong wire %d situation", unitemp_gpio_toInt(bus->gpio));
-                return 0;
-            }
-        }
-        unitemp_onewire_bus_send_bit(bus, next & 0x80);
-        bp--;
-        if(!bp) {
-            *pprev = next;
-            if(p >= 64) break;
-            next = 0;
-            pprev++;
-            prev = *pprev;
-            bp = 8;
-        } else {
-            if(p >= 64) break;
-            prev >>= 1;
-            next >>= 1;
-        }
-        p++;
+    if(onewire_host_search(bus->host, onewire_enum, OneWireHostSearchModeNormal)) {
+        return onewire_enum;
+    } else {
+        return NULL;
     }
-    onewire_enum_fork_bit = newfork;
-    return &onewire_enum[0];
 }
 
 void unitemp_onewire_bus_select_sensor(OneWireSensor* instance) {
@@ -364,7 +255,6 @@ bool unitemp_onewire_sensor_init(Sensor* sensor) {
     }
 
     unitemp_onewire_bus_init(instance->bus);
-    furi_delay_ms(1);
 
     if(instance->familyCode == FC_DS18B20 || instance->familyCode == FC_DS1822) {
         //Установка разрядности в 10 бит
diff --git a/applications/plugins/unitemp/interfaces/OneWireSensor.h b/applications/plugins/unitemp/interfaces/OneWireSensor.h
index ef94db820f..cb031d1616 100644
--- a/applications/plugins/unitemp/interfaces/OneWireSensor.h
+++ b/applications/plugins/unitemp/interfaces/OneWireSensor.h
@@ -19,6 +19,7 @@
 #define UNITEMP_OneWire
 
 #include "../unitemp.h"
+#include <one_wire/one_wire_host.h>
 
 //Коды семейства устройств
 typedef enum DallasFamilyCode {
@@ -42,6 +43,8 @@ typedef struct {
     int8_t device_count;
     //Режим питания датчиков на шине
     PowerMode powerMode;
+
+    OneWireHost* host;
 } OneWireBus;
 
 //Инстанс датчика one wire
@@ -155,7 +158,7 @@ bool unitemp_onewire_bus_read_bit(OneWireBus* bus);
  * 
  * @param bus Указатель на шину one wire
  * @return Байт информации
- */
+ **/
 uint8_t unitemp_onewire_bus_read_byte(OneWireBus* bus);
 
 /**
@@ -201,7 +204,7 @@ void unitemp_onewire_bus_select_sensor(OneWireSensor* instance);
 /**
  * @brief Инициализация процесса поиска адресов на шине one wire
  */
-void unitemp_onewire_bus_enum_init(void);
+void unitemp_onewire_bus_enum_init(OneWireBus* bus);
 
 /**
  * @brief Перечисляет устройства на шине one wire и получает очередной адрес
diff --git a/applications/plugins/unitemp/unitemp.c b/applications/plugins/unitemp/unitemp.c
index 181de0e782..fbf9eca55d 100644
--- a/applications/plugins/unitemp/unitemp.c
+++ b/applications/plugins/unitemp/unitemp.c
@@ -36,6 +36,9 @@ void unitemp_pascalToMmHg(Sensor* sensor) {
 void unitemp_pascalToKPa(Sensor* sensor) {
     sensor->pressure = sensor->pressure / 1000.0f;
 }
+void unitemp_pascalToHPa(Sensor* sensor) {
+    sensor->pressure = sensor->pressure / 100.0f;
+}
 void unitemp_pascalToInHg(Sensor* sensor) {
     sensor->pressure = sensor->pressure * 0.0002953007;
 }
@@ -306,4 +309,4 @@ int32_t unitemp_app() {
     unitemp_free();
     //Выход
     return 0;
-}
\ No newline at end of file
+}
diff --git a/applications/plugins/unitemp/unitemp.h b/applications/plugins/unitemp/unitemp.h
index bde8b0c177..4d184b2c37 100644
--- a/applications/plugins/unitemp/unitemp.h
+++ b/applications/plugins/unitemp/unitemp.h
@@ -67,6 +67,7 @@ typedef enum {
     UT_PRESSURE_MM_HG,
     UT_PRESSURE_IN_HG,
     UT_PRESSURE_KPA,
+    UT_PRESSURE_HPA,
 
     UT_PRESSURE_COUNT
 } pressureMeasureUnit;
@@ -135,6 +136,12 @@ void unitemp_pascalToKPa(Sensor* sensor);
  * 
  * @param sensor Указатель на датчик
  */
+void unitemp_pascalToHPa(Sensor* sensor);
+/**
+ * 
+ * Mod BySepa - linktr.ee/BySepa
+ * 
+ */
 void unitemp_pascalToInHg(Sensor* sensor);
 
 /**
@@ -151,4 +158,4 @@ bool unitemp_saveSettings(void);
 bool unitemp_loadSettings(void);
 
 extern Unitemp* app;
-#endif
\ No newline at end of file
+#endif
diff --git a/applications/plugins/unitemp/views/General_view.c b/applications/plugins/unitemp/views/General_view.c
index dcf8420d90..2c8d389bfa 100644
--- a/applications/plugins/unitemp/views/General_view.c
+++ b/applications/plugins/unitemp/views/General_view.c
@@ -116,14 +116,20 @@ static void _draw_humidity(Canvas* canvas, Sensor* sensor, const uint8_t pos[2])
 static void _draw_pressure(Canvas* canvas, Sensor* sensor) {
     const uint8_t x = 29, y = 39;
     //Рисование рамки
-    canvas_draw_rframe(canvas, x, y, 69, 20, 3);
-    canvas_draw_rframe(canvas, x, y, 69, 19, 3);
+    if(app->settings.pressure_unit == UT_PRESSURE_HPA) {
+        canvas_draw_rframe(canvas, x, y, 84, 20, 3);
+        canvas_draw_rframe(canvas, x, y, 84, 19, 3);
+    } else {
+        canvas_draw_rframe(canvas, x, y, 69, 20, 3);
+        canvas_draw_rframe(canvas, x, y, 69, 19, 3);
+    }
 
     //Рисование иконки
     canvas_draw_icon(canvas, x + 3, y + 4, &I_pressure_7x13);
 
     int16_t press_int = sensor->pressure;
-    int8_t press_dec = (int16_t)(sensor->temp * 10) % 10;
+    // Change Temp for Pressure
+    int8_t press_dec = (int16_t)(sensor->pressure * 10) % 10;
 
     //Целая часть давления
     snprintf(app->buff, BUFF_SIZE, "%d", press_int);
@@ -136,15 +142,23 @@ static void _draw_pressure(Canvas* canvas, Sensor* sensor) {
         snprintf(app->buff, BUFF_SIZE, ".%d", press_dec);
         canvas_set_font(canvas, FontPrimary);
         canvas_draw_str(canvas, x + 27 + int_len / 2 + 2, y + 10 + 7, app->buff);
+    } else if(app->settings.pressure_unit == UT_PRESSURE_HPA) {
+        uint8_t int_len = canvas_string_width(canvas, app->buff);
+        snprintf(app->buff, BUFF_SIZE, ".%d", press_dec);
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str(canvas, x + 32 + int_len / 2 + 2, y + 10 + 7, app->buff);
     }
     canvas_set_font(canvas, FontSecondary);
     //Единица измерения
+
     if(app->settings.pressure_unit == UT_PRESSURE_MM_HG) {
         canvas_draw_icon(canvas, x + 50, y + 2, &I_mm_hg_15x15);
     } else if(app->settings.pressure_unit == UT_PRESSURE_IN_HG) {
         canvas_draw_icon(canvas, x + 50, y + 2, &I_in_hg_15x15);
     } else if(app->settings.pressure_unit == UT_PRESSURE_KPA) {
         canvas_draw_str(canvas, x + 52, y + 13, "kPa");
+    } else if(app->settings.pressure_unit == UT_PRESSURE_HPA) {
+        canvas_draw_str(canvas, x + 67, y + 13, "hPa");
     }
 }
 
diff --git a/applications/plugins/unitemp/views/SensorEdit_view.c b/applications/plugins/unitemp/views/SensorEdit_view.c
index ccb07a48e4..c1ac4c028a 100644
--- a/applications/plugins/unitemp/views/SensorEdit_view.c
+++ b/applications/plugins/unitemp/views/SensorEdit_view.c
@@ -75,7 +75,7 @@ static void _onewire_scan(void) {
     } while(_onewire_id_exist(id));
 
     if(id == NULL) {
-        unitemp_onewire_bus_enum_init();
+        unitemp_onewire_bus_enum_init(ow_sensor->bus);
         id = unitemp_onewire_bus_enum_next(ow_sensor->bus);
         if(_onewire_id_exist(id)) {
             do {
diff --git a/applications/plugins/unitemp/views/Settings_view.c b/applications/plugins/unitemp/views/Settings_view.c
index bff1691294..e61c6cad6a 100644
--- a/applications/plugins/unitemp/views/Settings_view.c
+++ b/applications/plugins/unitemp/views/Settings_view.c
@@ -25,7 +25,7 @@ static VariableItemList* variable_item_list;
 
 static const char states[2][9] = {"Auto", "Infinity"};
 static const char temp_units[UT_TEMP_COUNT][3] = {"*C", "*F"};
-static const char pressure_units[UT_PRESSURE_COUNT][6] = {"mm Hg", "in Hg", "kPa"};
+static const char pressure_units[UT_PRESSURE_COUNT][6] = {"mm Hg", "in Hg", "kPa", "hPA"};
 
 //Элемент списка - бесконечная подсветка
 VariableItem* infinity_backlight_item;
@@ -149,4 +149,4 @@ void unitemp_Settings_free(void) {
     view_free(view);
     //Удаление вида после обработки
     view_dispatcher_remove_view(app->view_dispatcher, VIEW_ID);
-}
\ No newline at end of file
+}
diff --git a/applications/plugins/weather_station/helpers/weather_station_types.h b/applications/plugins/weather_station/helpers/weather_station_types.h
index 1f5612e2e9..111465978b 100644
--- a/applications/plugins/weather_station/helpers/weather_station_types.h
+++ b/applications/plugins/weather_station/helpers/weather_station_types.h
@@ -3,7 +3,7 @@
 #include <furi.h>
 #include <furi_hal.h>
 
-#define WS_VERSION_APP "0.7"
+#define WS_VERSION_APP "0.8"
 #define WS_DEVELOPED "SkorP"
 #define WS_GITHUB "https://github.com/flipperdevices/flipperzero-firmware"
 
diff --git a/applications/plugins/weather_station/protocols/acurite_592txr.c b/applications/plugins/weather_station/protocols/acurite_592txr.c
index 5384a3c919..874f6dd33b 100644
--- a/applications/plugins/weather_station/protocols/acurite_592txr.c
+++ b/applications/plugins/weather_station/protocols/acurite_592txr.c
@@ -258,7 +258,7 @@ uint8_t ws_protocol_decoder_acurite_592txr_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_acurite_592txr_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_acurite_592txr_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -267,22 +267,14 @@ bool ws_protocol_decoder_acurite_592txr_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_acurite_592txr_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_acurite_592txr_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderAcurite_592TXR* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_acurite_592txr_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        ws_protocol_acurite_592txr_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_acurite_592txr_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/acurite_592txr.h b/applications/plugins/weather_station/protocols/acurite_592txr.h
index ac0371d89e..1071d1cf77 100644
--- a/applications/plugins/weather_station/protocols/acurite_592txr.h
+++ b/applications/plugins/weather_station/protocols/acurite_592txr.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_acurite_592txr_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderAcurite_592TXR instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_acurite_592txr_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_acurite_592txr_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_acurite_592txr_serialize(
  * Deserialize data WSProtocolDecoderAcurite_592TXR.
  * @param context Pointer to a WSProtocolDecoderAcurite_592TXR instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_acurite_592txr_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_acurite_592txr_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/acurite_606tx.c b/applications/plugins/weather_station/protocols/acurite_606tx.c
index 4cb5d18b8f..e0d405c662 100644
--- a/applications/plugins/weather_station/protocols/acurite_606tx.c
+++ b/applications/plugins/weather_station/protocols/acurite_606tx.c
@@ -199,7 +199,7 @@ uint8_t ws_protocol_decoder_acurite_606tx_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_acurite_606tx_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_acurite_606tx_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -208,22 +208,14 @@ bool ws_protocol_decoder_acurite_606tx_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_acurite_606tx_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_acurite_606tx_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderAcurite_606TX* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_acurite_606tx_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        ws_protocol_acurite_606tx_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_acurite_606tx_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/acurite_606tx.h b/applications/plugins/weather_station/protocols/acurite_606tx.h
index 5bab3bcb79..15b6d1eb50 100644
--- a/applications/plugins/weather_station/protocols/acurite_606tx.h
+++ b/applications/plugins/weather_station/protocols/acurite_606tx.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_acurite_606tx_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderAcurite_606TX instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_acurite_606tx_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_acurite_606tx_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_acurite_606tx_serialize(
  * Deserialize data WSProtocolDecoderAcurite_606TX.
  * @param context Pointer to a WSProtocolDecoderAcurite_606TX instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_acurite_606tx_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_acurite_606tx_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/acurite_609txc.c b/applications/plugins/weather_station/protocols/acurite_609txc.c
index aeb0785eb5..853b78446c 100644
--- a/applications/plugins/weather_station/protocols/acurite_609txc.c
+++ b/applications/plugins/weather_station/protocols/acurite_609txc.c
@@ -199,7 +199,7 @@ uint8_t ws_protocol_decoder_acurite_609txc_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_acurite_609txc_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_acurite_609txc_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -208,22 +208,14 @@ bool ws_protocol_decoder_acurite_609txc_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_acurite_609txc_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_acurite_609txc_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderAcurite_609TXC* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_acurite_609txc_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        ws_protocol_acurite_609txc_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_acurite_609txc_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/acurite_609txc.h b/applications/plugins/weather_station/protocols/acurite_609txc.h
index f87c20e9b7..3e3b9cee8d 100644
--- a/applications/plugins/weather_station/protocols/acurite_609txc.h
+++ b/applications/plugins/weather_station/protocols/acurite_609txc.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_acurite_609txc_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderAcurite_609TXC instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_acurite_609txc_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_acurite_609txc_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_acurite_609txc_serialize(
  * Deserialize data WSProtocolDecoderAcurite_609TXC.
  * @param context Pointer to a WSProtocolDecoderAcurite_609TXC instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_acurite_609txc_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_acurite_609txc_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/ambient_weather.c b/applications/plugins/weather_station/protocols/ambient_weather.c
index e3c85f40ba..588a7f82ae 100644
--- a/applications/plugins/weather_station/protocols/ambient_weather.c
+++ b/applications/plugins/weather_station/protocols/ambient_weather.c
@@ -228,7 +228,7 @@ uint8_t ws_protocol_decoder_ambient_weather_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_ambient_weather_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_ambient_weather_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -237,22 +237,14 @@ bool ws_protocol_decoder_ambient_weather_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_ambient_weather_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_ambient_weather_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderAmbient_Weather* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_ambient_weather_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        ws_protocol_ambient_weather_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_ambient_weather_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/ambient_weather.h b/applications/plugins/weather_station/protocols/ambient_weather.h
index 04cc5819c2..1694403cd1 100644
--- a/applications/plugins/weather_station/protocols/ambient_weather.h
+++ b/applications/plugins/weather_station/protocols/ambient_weather.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_ambient_weather_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderAmbient_Weather instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_ambient_weather_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_ambient_weather_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_ambient_weather_serialize(
  * Deserialize data WSProtocolDecoderAmbient_Weather.
  * @param context Pointer to a WSProtocolDecoderAmbient_Weather instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_ambient_weather_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_ambient_weather_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/auriol_hg0601a.c b/applications/plugins/weather_station/protocols/auriol_hg0601a.c
index d5f89fc8bd..813fe1526c 100644
--- a/applications/plugins/weather_station/protocols/auriol_hg0601a.c
+++ b/applications/plugins/weather_station/protocols/auriol_hg0601a.c
@@ -210,7 +210,7 @@ uint8_t ws_protocol_decoder_auriol_th_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_auriol_th_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_auriol_th_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -219,22 +219,12 @@ bool ws_protocol_decoder_auriol_th_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_auriol_th_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_auriol_th_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderAuriol_TH* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_auriol_th_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_auriol_th_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_auriol_th_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/auriol_hg0601a.h b/applications/plugins/weather_station/protocols/auriol_hg0601a.h
index c23007c1a7..155bb07fc4 100644
--- a/applications/plugins/weather_station/protocols/auriol_hg0601a.h
+++ b/applications/plugins/weather_station/protocols/auriol_hg0601a.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_auriol_th_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderAuriol_TH instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_auriol_th_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_auriol_th_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_auriol_th_serialize(
  * Deserialize data WSProtocolDecoderAuriol_TH.
  * @param context Pointer to a WSProtocolDecoderAuriol_TH instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_auriol_th_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_auriol_th_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/gt_wt_02.c b/applications/plugins/weather_station/protocols/gt_wt_02.c
index cbe119192a..d333164b49 100644
--- a/applications/plugins/weather_station/protocols/gt_wt_02.c
+++ b/applications/plugins/weather_station/protocols/gt_wt_02.c
@@ -217,7 +217,7 @@ uint8_t ws_protocol_decoder_gt_wt_02_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_gt_wt_02_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_gt_wt_02_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -226,22 +226,12 @@ bool ws_protocol_decoder_gt_wt_02_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_gt_wt_02_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_gt_wt_02_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderGT_WT02* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_gt_wt_02_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_gt_wt_02_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_gt_wt_02_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/gt_wt_02.h b/applications/plugins/weather_station/protocols/gt_wt_02.h
index f17d5baa07..e13576d218 100644
--- a/applications/plugins/weather_station/protocols/gt_wt_02.h
+++ b/applications/plugins/weather_station/protocols/gt_wt_02.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_gt_wt_02_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderGT_WT02 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_gt_wt_02_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_gt_wt_02_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_gt_wt_02_serialize(
  * Deserialize data WSProtocolDecoderGT_WT02.
  * @param context Pointer to a WSProtocolDecoderGT_WT02 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_gt_wt_02_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_gt_wt_02_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/gt_wt_03.c b/applications/plugins/weather_station/protocols/gt_wt_03.c
index 7831cf0695..30430b8390 100644
--- a/applications/plugins/weather_station/protocols/gt_wt_03.c
+++ b/applications/plugins/weather_station/protocols/gt_wt_03.c
@@ -292,7 +292,7 @@ uint8_t ws_protocol_decoder_gt_wt_03_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_gt_wt_03_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_gt_wt_03_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -301,22 +301,12 @@ bool ws_protocol_decoder_gt_wt_03_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_gt_wt_03_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_gt_wt_03_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderGT_WT03* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_gt_wt_03_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_gt_wt_03_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_gt_wt_03_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/gt_wt_03.h b/applications/plugins/weather_station/protocols/gt_wt_03.h
index fd9536e342..d566bb399c 100644
--- a/applications/plugins/weather_station/protocols/gt_wt_03.h
+++ b/applications/plugins/weather_station/protocols/gt_wt_03.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_gt_wt_03_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderGT_WT03 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_gt_wt_03_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_gt_wt_03_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_gt_wt_03_serialize(
  * Deserialize data WSProtocolDecoderGT_WT03.
  * @param context Pointer to a WSProtocolDecoderGT_WT03 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_gt_wt_03_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_gt_wt_03_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/infactory.c b/applications/plugins/weather_station/protocols/infactory.c
index 53a656d738..4b0e6602a5 100644
--- a/applications/plugins/weather_station/protocols/infactory.c
+++ b/applications/plugins/weather_station/protocols/infactory.c
@@ -248,7 +248,7 @@ uint8_t ws_protocol_decoder_infactory_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_infactory_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_infactory_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -257,22 +257,12 @@ bool ws_protocol_decoder_infactory_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_infactory_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_infactory_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderInfactory* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_infactory_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_infactory_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_infactory_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/infactory.h b/applications/plugins/weather_station/protocols/infactory.h
index 2792ab9873..9431a067ea 100644
--- a/applications/plugins/weather_station/protocols/infactory.h
+++ b/applications/plugins/weather_station/protocols/infactory.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_infactory_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderInfactory instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_infactory_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_infactory_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_infactory_serialize(
  * Deserialize data WSProtocolDecoderInfactory.
  * @param context Pointer to a WSProtocolDecoderInfactory instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_infactory_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_infactory_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/lacrosse_tx.c b/applications/plugins/weather_station/protocols/lacrosse_tx.c
index 8d8a24e244..f4b850d769 100644
--- a/applications/plugins/weather_station/protocols/lacrosse_tx.c
+++ b/applications/plugins/weather_station/protocols/lacrosse_tx.c
@@ -281,7 +281,7 @@ uint8_t ws_protocol_decoder_lacrosse_tx_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_lacrosse_tx_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_lacrosse_tx_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -290,22 +290,12 @@ bool ws_protocol_decoder_lacrosse_tx_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_lacrosse_tx_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_lacrosse_tx_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderLaCrosse_TX* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_lacrosse_tx_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_lacrosse_tx_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_lacrosse_tx_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/lacrosse_tx.h b/applications/plugins/weather_station/protocols/lacrosse_tx.h
index e884556897..151282b3a0 100644
--- a/applications/plugins/weather_station/protocols/lacrosse_tx.h
+++ b/applications/plugins/weather_station/protocols/lacrosse_tx.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_lacrosse_tx_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderLaCrosse_TX instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_lacrosse_tx_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_lacrosse_tx_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_lacrosse_tx_serialize(
  * Deserialize data WSProtocolDecoderLaCrosse_TX.
  * @param context Pointer to a WSProtocolDecoderLaCrosse_TX instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_lacrosse_tx_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_lacrosse_tx_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.c b/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.c
index e4b6122501..5d007b12fb 100644
--- a/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.c
+++ b/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.c
@@ -247,7 +247,7 @@ uint8_t ws_protocol_decoder_lacrosse_tx141thbv2_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_lacrosse_tx141thbv2_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_lacrosse_tx141thbv2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -256,24 +256,15 @@ bool ws_protocol_decoder_lacrosse_tx141thbv2_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_lacrosse_tx141thbv2_deserialize(
+SubGhzProtocolStatus ws_protocol_decoder_lacrosse_tx141thbv2_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderLaCrosse_TX141THBv2* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_lacrosse_tx141thbv2_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        ws_protocol_lacrosse_tx141thbv2_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_lacrosse_tx141thbv2_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.h b/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.h
index 941b010581..036db05481 100644
--- a/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.h
+++ b/applications/plugins/weather_station/protocols/lacrosse_tx141thbv2.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_lacrosse_tx141thbv2_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderLaCrosse_TX141THBv2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_lacrosse_tx141thbv2_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_lacrosse_tx141thbv2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,9 @@ bool ws_protocol_decoder_lacrosse_tx141thbv2_serialize(
  * Deserialize data WSProtocolDecoderLaCrosse_TX141THBv2.
  * @param context Pointer to a WSProtocolDecoderLaCrosse_TX141THBv2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_lacrosse_tx141thbv2_deserialize(
+SubGhzProtocolStatus ws_protocol_decoder_lacrosse_tx141thbv2_deserialize(
     void* context,
     FlipperFormat* flipper_format);
 
diff --git a/applications/plugins/weather_station/protocols/nexus_th.c b/applications/plugins/weather_station/protocols/nexus_th.c
index 38f2fe895c..14ba8b273a 100644
--- a/applications/plugins/weather_station/protocols/nexus_th.c
+++ b/applications/plugins/weather_station/protocols/nexus_th.c
@@ -216,7 +216,7 @@ uint8_t ws_protocol_decoder_nexus_th_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_nexus_th_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_nexus_th_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -225,22 +225,12 @@ bool ws_protocol_decoder_nexus_th_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_nexus_th_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_nexus_th_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderNexus_TH* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_nexus_th_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_nexus_th_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_nexus_th_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/nexus_th.h b/applications/plugins/weather_station/protocols/nexus_th.h
index 5450f0040e..6c2715b851 100644
--- a/applications/plugins/weather_station/protocols/nexus_th.h
+++ b/applications/plugins/weather_station/protocols/nexus_th.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_nexus_th_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderNexus_TH instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_nexus_th_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_nexus_th_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_nexus_th_serialize(
  * Deserialize data WSProtocolDecoderNexus_TH.
  * @param context Pointer to a WSProtocolDecoderNexus_TH instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_nexus_th_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_nexus_th_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/oregon2.c b/applications/plugins/weather_station/protocols/oregon2.c
index 8ca80bbe25..313748ccfb 100644
--- a/applications/plugins/weather_station/protocols/oregon2.c
+++ b/applications/plugins/weather_station/protocols/oregon2.c
@@ -302,17 +302,19 @@ uint8_t ws_protocol_decoder_oregon2_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_oregon2_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_oregon2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     WSProtocolDecoderOregon2* instance = context;
-    if(!ws_block_generic_serialize(&instance->generic, flipper_format, preset)) return false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    ret = ws_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if(ret != SubGhzProtocolStatusOk) return ret;
     uint32_t temp = instance->var_bits;
     if(!flipper_format_write_uint32(flipper_format, "VarBits", &temp, 1)) {
         FURI_LOG_E(TAG, "Error adding VarBits");
-        return false;
+        return SubGhzProtocolStatusErrorParserOthers;
     }
     if(!flipper_format_write_hex(
            flipper_format,
@@ -320,22 +322,25 @@ bool ws_protocol_decoder_oregon2_serialize(
            (const uint8_t*)&instance->var_data,
            sizeof(instance->var_data))) {
         FURI_LOG_E(TAG, "Error adding VarData");
-        return false;
+        return SubGhzProtocolStatusErrorParserOthers;
     }
-    return true;
+    return ret;
 }
 
-bool ws_protocol_decoder_oregon2_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_oregon2_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderOregon2* instance = context;
-    bool ret = false;
     uint32_t temp_data;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = ws_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "VarBits", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing VarLen");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->var_bits = (uint8_t)temp_data;
@@ -345,13 +350,14 @@ bool ws_protocol_decoder_oregon2_deserialize(void* context, FlipperFormat* flipp
                (uint8_t*)&instance->var_data,
                sizeof(instance->var_data))) { //-V1051
             FURI_LOG_E(TAG, "Missing VarData");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(instance->generic.data_count_bit != ws_oregon2_const.min_count_bit_for_found) {
             FURI_LOG_E(TAG, "Wrong number of bits in key: %d", instance->generic.data_count_bit);
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/applications/plugins/weather_station/protocols/oregon_v1.c b/applications/plugins/weather_station/protocols/oregon_v1.c
index 1ed9da205c..03215bbf5f 100644
--- a/applications/plugins/weather_station/protocols/oregon_v1.c
+++ b/applications/plugins/weather_station/protocols/oregon_v1.c
@@ -283,7 +283,7 @@ uint8_t ws_protocol_decoder_oregon_v1_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_oregon_v1_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_oregon_v1_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -292,22 +292,12 @@ bool ws_protocol_decoder_oregon_v1_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_oregon_v1_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_oregon_v1_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderOregon_V1* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_oregon_v1_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_oregon_v1_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_oregon_v1_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/oregon_v1.h b/applications/plugins/weather_station/protocols/oregon_v1.h
index c9aa5af48a..48937601de 100644
--- a/applications/plugins/weather_station/protocols/oregon_v1.h
+++ b/applications/plugins/weather_station/protocols/oregon_v1.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_oregon_v1_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_oregon_v1_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_oregon_v1_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_oregon_v1_serialize(
  * Deserialize data WSProtocolDecoderOregon_V1.
  * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_oregon_v1_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_oregon_v1_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/thermopro_tx4.c b/applications/plugins/weather_station/protocols/thermopro_tx4.c
index 0882bc33d7..24e883e607 100644
--- a/applications/plugins/weather_station/protocols/thermopro_tx4.c
+++ b/applications/plugins/weather_station/protocols/thermopro_tx4.c
@@ -211,7 +211,7 @@ uint8_t ws_protocol_decoder_thermopro_tx4_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_thermopro_tx4_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_thermopro_tx4_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -220,22 +220,14 @@ bool ws_protocol_decoder_thermopro_tx4_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_thermopro_tx4_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_thermopro_tx4_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderThermoPRO_TX4* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           ws_protocol_thermopro_tx4_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        ws_protocol_thermopro_tx4_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_thermopro_tx4_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/thermopro_tx4.h b/applications/plugins/weather_station/protocols/thermopro_tx4.h
index 1feae58d30..526648d1ee 100644
--- a/applications/plugins/weather_station/protocols/thermopro_tx4.h
+++ b/applications/plugins/weather_station/protocols/thermopro_tx4.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_thermopro_tx4_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderThermoPRO_TX4 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_thermopro_tx4_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_thermopro_tx4_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_thermopro_tx4_serialize(
  * Deserialize data WSProtocolDecoderThermoPRO_TX4.
  * @param context Pointer to a WSProtocolDecoderThermoPRO_TX4 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_thermopro_tx4_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_thermopro_tx4_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/tx_8300.c b/applications/plugins/weather_station/protocols/tx_8300.c
index ee0412ba9c..3a06ce49de 100644
--- a/applications/plugins/weather_station/protocols/tx_8300.c
+++ b/applications/plugins/weather_station/protocols/tx_8300.c
@@ -246,7 +246,7 @@ uint8_t ws_protocol_decoder_tx_8300_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool ws_protocol_decoder_tx_8300_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_tx_8300_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -255,21 +255,12 @@ bool ws_protocol_decoder_tx_8300_serialize(
     return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool ws_protocol_decoder_tx_8300_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_protocol_decoder_tx_8300_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     WSProtocolDecoderTX_8300* instance = context;
-    bool ret = false;
-    do {
-        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit != ws_protocol_tx_8300_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return ws_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, ws_protocol_tx_8300_const.min_count_bit_for_found);
 }
 
 void ws_protocol_decoder_tx_8300_get_string(void* context, FuriString* output) {
diff --git a/applications/plugins/weather_station/protocols/tx_8300.h b/applications/plugins/weather_station/protocols/tx_8300.h
index ec198e80fa..088ccd7c03 100644
--- a/applications/plugins/weather_station/protocols/tx_8300.h
+++ b/applications/plugins/weather_station/protocols/tx_8300.h
@@ -56,9 +56,9 @@ uint8_t ws_protocol_decoder_tx_8300_get_hash_data(void* context);
  * @param context Pointer to a WSProtocolDecoderTX_8300 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_tx_8300_serialize(
+SubGhzProtocolStatus ws_protocol_decoder_tx_8300_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -67,9 +67,10 @@ bool ws_protocol_decoder_tx_8300_serialize(
  * Deserialize data WSProtocolDecoderTX_8300.
  * @param context Pointer to a WSProtocolDecoderTX_8300 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_protocol_decoder_tx_8300_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_protocol_decoder_tx_8300_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/applications/plugins/weather_station/protocols/ws_generic.c b/applications/plugins/weather_station/protocols/ws_generic.c
index 8a88ed52f3..026856a9eb 100644
--- a/applications/plugins/weather_station/protocols/ws_generic.c
+++ b/applications/plugins/weather_station/protocols/ws_generic.c
@@ -21,12 +21,12 @@ void ws_block_generic_get_preset_name(const char* preset_name, FuriString* prese
     furi_string_set(preset_str, preset_name_temp);
 }
 
-bool ws_block_generic_serialize(
+SubGhzProtocolStatus ws_block_generic_serialize(
     WSBlockGeneric* instance,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(instance);
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     do {
@@ -34,11 +34,13 @@ bool ws_block_generic_serialize(
         if(!flipper_format_write_header_cstr(
                flipper_format, WS_KEY_FILE_TYPE, WS_KEY_FILE_VERSION)) {
             FURI_LOG_E(TAG, "Unable to add header");
+            res = SubGhzProtocolStatusErrorParserHeader;
             break;
         }
 
         if(!flipper_format_write_uint32(flipper_format, "Frequency", &preset->frequency, 1)) {
             FURI_LOG_E(TAG, "Unable to add Frequency");
+            res = SubGhzProtocolStatusErrorParserFrequency;
             break;
         }
 
@@ -46,34 +48,40 @@ bool ws_block_generic_serialize(
         if(!flipper_format_write_string_cstr(
                flipper_format, "Preset", furi_string_get_cstr(temp_str))) {
             FURI_LOG_E(TAG, "Unable to add Preset");
+            res = SubGhzProtocolStatusErrorParserPreset;
             break;
         }
         if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
             if(!flipper_format_write_string_cstr(
                    flipper_format, "Custom_preset_module", "CC1101")) {
                 FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
                 break;
             }
             if(!flipper_format_write_hex(
                    flipper_format, "Custom_preset_data", preset->data, preset->data_size)) {
                 FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
                 break;
             }
         }
         if(!flipper_format_write_string_cstr(flipper_format, "Protocol", instance->protocol_name)) {
             FURI_LOG_E(TAG, "Unable to add Protocol");
+            res = SubGhzProtocolStatusErrorParserProtocolName;
             break;
         }
 
         uint32_t temp_data = instance->id;
         if(!flipper_format_write_uint32(flipper_format, "Id", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Id");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         temp_data = instance->data_count_bit;
         if(!flipper_format_write_uint32(flipper_format, "Bit", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
 
@@ -84,18 +92,21 @@ bool ws_block_generic_serialize(
 
         if(!flipper_format_write_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to add Data");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         temp_data = instance->battery_low;
         if(!flipper_format_write_uint32(flipper_format, "Batt", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Battery_low");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         temp_data = instance->humidity;
         if(!flipper_format_write_uint32(flipper_format, "Hum", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Humidity");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
@@ -107,52 +118,60 @@ bool ws_block_generic_serialize(
         temp_data = curr_ts;
         if(!flipper_format_write_uint32(flipper_format, "Ts", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add timestamp");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         temp_data = instance->channel;
         if(!flipper_format_write_uint32(flipper_format, "Ch", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Channel");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         temp_data = instance->btn;
         if(!flipper_format_write_uint32(flipper_format, "Btn", &temp_data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Btn");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         float temp = instance->temp;
         if(!flipper_format_write_float(flipper_format, "Temp", &temp, 1)) {
             FURI_LOG_E(TAG, "Unable to add Temperature");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
     furi_string_free(temp_str);
     return res;
 }
 
-bool ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipper_format) {
     furi_assert(instance);
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     uint32_t temp_data = 0;
 
     do {
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         if(!flipper_format_read_uint32(flipper_format, "Id", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Id");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->id = (uint32_t)temp_data;
 
         if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
         instance->data_count_bit = (uint8_t)temp_data;
@@ -160,6 +179,7 @@ bool ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipp
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Missing Data");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
@@ -169,30 +189,35 @@ bool ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipp
 
         if(!flipper_format_read_uint32(flipper_format, "Batt", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Battery_low");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->battery_low = (uint8_t)temp_data;
 
         if(!flipper_format_read_uint32(flipper_format, "Hum", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Humidity");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->humidity = (uint8_t)temp_data;
 
         if(!flipper_format_read_uint32(flipper_format, "Ts", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing timestamp");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->timestamp = (uint32_t)temp_data;
 
         if(!flipper_format_read_uint32(flipper_format, "Ch", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Channel");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->channel = (uint8_t)temp_data;
 
         if(!flipper_format_read_uint32(flipper_format, "Btn", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Btn");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->btn = (uint8_t)temp_data;
@@ -200,12 +225,32 @@ bool ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipp
         float temp;
         if(!flipper_format_read_float(flipper_format, "Temp", (float*)&temp, 1)) {
             FURI_LOG_E(TAG, "Missing Temperature");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         instance->temp = temp;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(0);
 
     return res;
+}
+
+SubGhzProtocolStatus ws_block_generic_deserialize_check_count_bit(
+    WSBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    uint16_t count_bit) {
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = ws_block_generic_deserialize(instance, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->data_count_bit != count_bit) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
 }
\ No newline at end of file
diff --git a/applications/plugins/weather_station/protocols/ws_generic.h b/applications/plugins/weather_station/protocols/ws_generic.h
index 47cfa74b3a..ff047fae65 100644
--- a/applications/plugins/weather_station/protocols/ws_generic.h
+++ b/applications/plugins/weather_station/protocols/ws_generic.h
@@ -48,9 +48,9 @@ void ws_block_generic_get_preset_name(const char* preset_name, FuriString* prese
  * @param instance Pointer to a WSBlockGeneric instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool ws_block_generic_serialize(
+SubGhzProtocolStatus ws_block_generic_serialize(
     WSBlockGeneric* instance,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -59,9 +59,22 @@ bool ws_block_generic_serialize(
  * Deserialize data WSBlockGeneric.
  * @param instance Pointer to a WSBlockGeneric instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    ws_block_generic_deserialize(WSBlockGeneric* instance, FlipperFormat* flipper_format);
+
+/**
+ * Deserialize data WSBlockGeneric.
+ * @param instance Pointer to a WSBlockGeneric instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param count_bit Count bit protocol
+ * @return status
+ */
+SubGhzProtocolStatus ws_block_generic_deserialize_check_count_bit(
+    WSBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    uint16_t count_bit);
 
 #ifdef __cplusplus
 }
diff --git a/applications/plugins/weather_station/weather_station_app.c b/applications/plugins/weather_station/weather_station_app.c
index b17f2acfc6..ffa569f20b 100644
--- a/applications/plugins/weather_station/weather_station_app.c
+++ b/applications/plugins/weather_station/weather_station_app.c
@@ -105,6 +105,9 @@ WeatherStationApp* weather_station_app_alloc() {
         app->txrx->worker, (SubGhzWorkerPairCallback)subghz_receiver_decode);
     subghz_worker_set_context(app->txrx->worker, app->txrx->receiver);
 
+    // Enable power for External CC1101 if it is connected
+    furi_hal_subghz_enable_ext_power();
+
     furi_hal_power_suppress_charge_enter();
 
     scene_manager_next_scene(app->scene_manager, WeatherStationSceneStart);
@@ -118,6 +121,9 @@ void weather_station_app_free(WeatherStationApp* app) {
     //CC1101 off
     ws_sleep(app);
 
+    // Disable power for External CC1101 if it was enabled and module is connected
+    furi_hal_subghz_disable_ext_power();
+
     // Submenu
     view_dispatcher_remove_view(app->view_dispatcher, WeatherStationViewSubmenu);
     submenu_free(app->submenu);
diff --git a/applications/plugins/wifi_scanner/wifi_scanner.c b/applications/plugins/wifi_scanner/wifi_scanner.c
index 826048e266..3a79ce16e3 100644
--- a/applications/plugins/wifi_scanner/wifi_scanner.c
+++ b/applications/plugins/wifi_scanner/wifi_scanner.c
@@ -83,6 +83,7 @@ typedef enum EWorkerEventFlags {
 } EWorkerEventFlags;
 
 typedef struct SWiFiScannerApp {
+    FuriMutex* mutex;
     Gui* m_gui;
     FuriThread* m_worker_thread;
     NotificationApp* m_notification;
@@ -162,10 +163,9 @@ void DrawSignalStrengthBar(Canvas* canvas, int rssi, int x, int y, int width, in
 }
 
 static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
-    SWiFiScannerApp* app = acquire_mutex((ValueMutex*)ctx, 25);
-    if(app == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    SWiFiScannerApp* app = ctx;
+    furi_mutex_acquire(app->mutex, FuriWaitForever);
 
     canvas_clear(canvas);
 
@@ -433,7 +433,7 @@ static void wifi_module_render_callback(Canvas* const canvas, void* ctx) {
             break;
         }
     }
-    release_mutex((ValueMutex*)ctx, app);
+    furi_mutex_release(app->mutex);
 }
 
 static void wifi_module_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -460,14 +460,15 @@ static void uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
 static int32_t uart_worker(void* context) {
     furi_assert(context);
 
-    SWiFiScannerApp* app = acquire_mutex((ValueMutex*)context, 25);
+    SWiFiScannerApp* app = context;
+    furi_mutex_acquire(app->mutex, FuriWaitForever);
     if(app == NULL) {
         return 1;
     }
 
     FuriStreamBuffer* rx_stream = app->m_rx_stream;
 
-    release_mutex((ValueMutex*)context, app);
+    furi_mutex_release(app->mutex);
 
     while(true) {
         uint32_t events = furi_thread_flags_wait(
@@ -527,7 +528,8 @@ static int32_t uart_worker(void* context) {
                 } while(end < stringSize);
                 furi_string_free(chunk);
 
-                app = acquire_mutex((ValueMutex*)context, 25);
+                app = context;
+                furi_mutex_acquire(app->mutex, FuriWaitForever);
                 if(app == NULL) {
                     return 1;
                 }
@@ -584,7 +586,7 @@ static int32_t uart_worker(void* context) {
                     }
                 }
 
-                release_mutex((ValueMutex*)context, app);
+                furi_mutex_release(app->mutex);
 
                 // Clear string array
                 for(index = 0; index < EChunkArrayData_ENUM_MAX; ++index) {
@@ -665,8 +667,9 @@ int32_t wifi_scanner_app(void* p) {
 #endif // ENABLE_MODULE_POWER
 #endif // ENABLE_MODULE_DETECTION
 
-    ValueMutex app_data_mutex;
-    if(!init_mutex(&app_data_mutex, app, sizeof(SWiFiScannerApp))) {
+    app->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+
+    if(!app->mutex) {
         WIFI_APP_LOG_E("cannot create mutex\r\n");
         free(app);
         return 255;
@@ -674,10 +677,10 @@ int32_t wifi_scanner_app(void* p) {
 
     WIFI_APP_LOG_I("Mutex created");
 
-    app->m_notification = furi_record_open("notification");
+    app->m_notification = furi_record_open(RECORD_NOTIFICATION);
 
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, wifi_module_render_callback, &app_data_mutex);
+    view_port_draw_callback_set(view_port, wifi_module_render_callback, app);
     view_port_input_callback_set(view_port, wifi_module_input_callback, event_queue);
 
     // Open GUI and register view_port
@@ -691,7 +694,7 @@ int32_t wifi_scanner_app(void* p) {
     app->m_worker_thread = furi_thread_alloc();
     furi_thread_set_name(app->m_worker_thread, "WiFiModuleUARTWorker");
     furi_thread_set_stack_size(app->m_worker_thread, 1024);
-    furi_thread_set_context(app->m_worker_thread, &app_data_mutex);
+    furi_thread_set_context(app->m_worker_thread, app);
     furi_thread_set_callback(app->m_worker_thread, uart_worker);
     furi_thread_start(app->m_worker_thread);
     WIFI_APP_LOG_I("UART thread allocated");
@@ -710,7 +713,7 @@ int32_t wifi_scanner_app(void* p) {
     SPluginEvent event;
     for(bool processing = true; processing;) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        SWiFiScannerApp* app = (SWiFiScannerApp*)acquire_mutex_block(&app_data_mutex);
+        furi_mutex_acquire(app->mutex, FuriWaitForever);
 
 #if ENABLE_MODULE_DETECTION
         if(!app->m_wifiModuleAttached) {
@@ -807,7 +810,7 @@ int32_t wifi_scanner_app(void* p) {
 #endif
 
         view_port_update(view_port);
-        release_mutex(&app_data_mutex, app);
+        furi_mutex_release(app->mutex);
     }
 
     WIFI_APP_LOG_I("Start exit app");
@@ -831,7 +834,7 @@ int32_t wifi_scanner_app(void* p) {
 
     // Close gui record
     furi_record_close(RECORD_GUI);
-    furi_record_close("notification");
+    furi_record_close(RECORD_NOTIFICATION);
     app->m_gui = NULL;
 
     view_port_free(view_port);
@@ -840,7 +843,7 @@ int32_t wifi_scanner_app(void* p) {
 
     furi_stream_buffer_free(app->m_rx_stream);
 
-    delete_mutex(&app_data_mutex);
+    furi_mutex_free(app->mutex);
 
     // Free rest
     free(app);
diff --git a/applications/plugins/zombiez/zombiez.c b/applications/plugins/zombiez/zombiez.c
index 2677d13e0b..602eea723e 100644
--- a/applications/plugins/zombiez/zombiez.c
+++ b/applications/plugins/zombiez/zombiez.c
@@ -52,6 +52,7 @@ typedef struct {
 } Projectile;
 
 typedef struct {
+    FuriMutex* mutex;
     GameState game_state;
     Player player;
 
@@ -66,10 +67,9 @@ typedef struct {
 } PluginState;
 
 static void render_callback(Canvas* const canvas, void* ctx) {
-    const PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
-    if(plugin_state == NULL) {
-        return;
-    }
+    furi_assert(ctx);
+    const PluginState* plugin_state = ctx;
+    furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
 
     canvas_draw_frame(canvas, 0, 0, 128, 64);
 
@@ -181,7 +181,7 @@ static void render_callback(Canvas* const canvas, void* ctx) {
     //canvas_draw_str_aligned(canvas, 32, 16, AlignLeft, AlignBottom, info);
     //free(info);
 
-    release_mutex((ValueMutex*)ctx, plugin_state);
+    furi_mutex_release(plugin_state->mutex);
 }
 
 static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
@@ -295,8 +295,8 @@ int32_t zombiez_game_app(void* p) {
     PluginState* plugin_state = malloc(sizeof(PluginState));
     zombiez_state_init(plugin_state);
 
-    ValueMutex state_mutex;
-    if(!init_mutex(&state_mutex, plugin_state, sizeof(PluginState))) {
+    plugin_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!plugin_state->mutex) {
         FURI_LOG_E("Zombiez", "cannot create mutex\r\n");
         return_code = 255;
         goto free_and_exit;
@@ -304,7 +304,7 @@ int32_t zombiez_game_app(void* p) {
 
     // Set system callbacks
     ViewPort* view_port = view_port_alloc();
-    view_port_draw_callback_set(view_port, render_callback, &state_mutex);
+    view_port_draw_callback_set(view_port, render_callback, plugin_state);
     view_port_input_callback_set(view_port, input_callback, event_queue);
 
     FuriTimer* timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, event_queue);
@@ -321,7 +321,7 @@ int32_t zombiez_game_app(void* p) {
     bool isRunning = true;
     while(isRunning) {
         FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
-        PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
+        furi_mutex_acquire(plugin_state->mutex, FuriWaitForever);
         if(event_status == FuriStatusOk) {
             if(event.type == EventTypeKey) {
                 if(event.input.type == InputTypePress) {
@@ -381,12 +381,10 @@ int32_t zombiez_game_app(void* p) {
             } else if(event.type == EventTypeTick) {
                 tick(plugin_state);
             }
-        } else {
-            // event timeout
         }
 
         view_port_update(view_port);
-        release_mutex(&state_mutex, plugin_state);
+        furi_mutex_release(plugin_state->mutex);
     }
 
     furi_timer_free(timer);
@@ -394,7 +392,7 @@ int32_t zombiez_game_app(void* p) {
     gui_remove_view_port(gui, view_port);
     furi_record_close(RECORD_GUI);
     view_port_free(view_port);
-    delete_mutex(&state_mutex);
+    furi_mutex_free(plugin_state->mutex);
 
 free_and_exit:
     free(plugin_state);
diff --git a/applications/services/applications.h b/applications/services/applications.h
index acbfea3125..871e9af54a 100644
--- a/applications/services/applications.h
+++ b/applications/services/applications.h
@@ -11,6 +11,7 @@ typedef enum {
 typedef struct {
     const FuriThreadCallback app;
     const char* name;
+    const char* appid;
     const size_t stack_size;
     const Icon* icon;
     const FlipperApplicationFlag flags;
diff --git a/applications/services/bt/bt_service/bt_api.c b/applications/services/bt/bt_service/bt_api.c
index e3cf78cc79..2f56b50a39 100644
--- a/applications/services/bt/bt_service/bt_api.c
+++ b/applications/services/bt/bt_service/bt_api.c
@@ -45,7 +45,14 @@ void bt_keys_storage_set_storage_path(Bt* bt, const char* keys_storage_path) {
     furi_assert(bt->keys_storage);
     furi_assert(keys_storage_path);
 
-    bt_keys_storage_set_file_path(bt->keys_storage, keys_storage_path);
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FuriString* path = furi_string_alloc_set(keys_storage_path);
+    storage_common_resolve_path_and_ensure_app_directory(storage, path);
+
+    bt_keys_storage_set_file_path(bt->keys_storage, furi_string_get_cstr(path));
+
+    furi_string_free(path);
+    furi_record_close(RECORD_STORAGE);
 }
 
 void bt_keys_storage_set_default_path(Bt* bt) {
diff --git a/applications/services/cli/cli_commands.c b/applications/services/cli/cli_commands.c
index 03b462369f..4e3e1104ae 100644
--- a/applications/services/cli/cli_commands.c
+++ b/applications/services/cli/cli_commands.c
@@ -382,11 +382,18 @@ void cli_command_ps(Cli* cli, FuriString* args, void* context) {
     FuriThreadId threads_ids[threads_num_max];
     uint8_t thread_num = furi_thread_enumerate(threads_ids, threads_num_max);
     printf(
-        "%-20s %-14s %-8s %-8s %s\r\n", "Name", "Stack start", "Heap", "Stack", "Stack min free");
+        "%-20s %-20s %-14s %-8s %-8s %s\r\n",
+        "AppID",
+        "Name",
+        "Stack start",
+        "Heap",
+        "Stack",
+        "Stack min free");
     for(uint8_t i = 0; i < thread_num; i++) {
         TaskControlBlock* tcb = (TaskControlBlock*)threads_ids[i];
         printf(
-            "%-20s 0x%-12lx %-8zu %-8lu %-8lu\r\n",
+            "%-20s %-20s 0x%-12lx %-8zu %-8lu %-8lu\r\n",
+            furi_thread_get_appid(threads_ids[i]),
             furi_thread_get_name(threads_ids[i]),
             (uint32_t)tcb->pxStack,
             memmgr_heap_get_thread_memory(threads_ids[i]),
diff --git a/applications/services/dialogs/dialogs_api.c b/applications/services/dialogs/dialogs_api.c
index ca2435b9b3..4723a1f91a 100644
--- a/applications/services/dialogs/dialogs_api.c
+++ b/applications/services/dialogs/dialogs_api.c
@@ -2,6 +2,7 @@
 #include "dialogs_i.h"
 #include <toolbox/api_lock.h>
 #include <assets_icons.h>
+#include <storage/storage.h>
 
 /****************** File browser ******************/
 
@@ -13,6 +14,22 @@ bool dialog_file_browser_show(
     FuriApiLock lock = api_lock_alloc_locked();
     furi_check(lock != NULL);
 
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FuriString* base_path = furi_string_alloc();
+
+    if(options && options->base_path) {
+        furi_string_set(base_path, options->base_path);
+        storage_common_resolve_path_and_ensure_app_directory(storage, base_path);
+    }
+
+    if(result_path) {
+        storage_common_resolve_path_and_ensure_app_directory(storage, result_path);
+    }
+
+    if(path) {
+        storage_common_resolve_path_and_ensure_app_directory(storage, path);
+    }
+
     DialogsAppData data = {
         .file_browser = {
             .extension = options ? options->extension : "",
@@ -24,7 +41,7 @@ bool dialog_file_browser_show(
             .preselected_filename = path,
             .item_callback = options ? options->item_loader_callback : NULL,
             .item_callback_context = options ? options->item_loader_context : NULL,
-            .base_path = options ? options->base_path : NULL,
+            .base_path = furi_string_get_cstr(base_path),
         }};
 
     DialogsAppReturn return_data;
@@ -39,6 +56,9 @@ bool dialog_file_browser_show(
         furi_message_queue_put(context->message_queue, &message, FuriWaitForever) == FuriStatusOk);
     api_lock_wait_unlock_and_free(lock);
 
+    furi_record_close(RECORD_STORAGE);
+    furi_string_free(base_path);
+
     return return_data.bool_value;
 }
 
diff --git a/applications/services/gui/modules/file_browser_worker.c b/applications/services/gui/modules/file_browser_worker.c
index 9d219429b6..326040020a 100644
--- a/applications/services/gui/modules/file_browser_worker.c
+++ b/applications/services/gui/modules/file_browser_worker.c
@@ -60,7 +60,7 @@ static bool browser_path_is_file(FuriString* path) {
     FileInfo file_info;
     Storage* storage = furi_record_open(RECORD_STORAGE);
     if(storage_common_stat(storage, furi_string_get_cstr(path), &file_info) == FSE_OK) {
-        if((file_info.flags & FSF_DIRECTORY) == 0) {
+        if(!file_info_is_dir(&file_info)) {
             state = true;
         }
     }
@@ -119,7 +119,7 @@ static bool browser_folder_check_and_switch(FuriString* path) {
     while(1) {
         // Check if folder is existing and navigate back if not
         if(storage_common_stat(storage, furi_string_get_cstr(path), &file_info) == FSE_OK) {
-            if(file_info.flags & FSF_DIRECTORY) {
+            if(file_info_is_dir(&file_info)) {
                 break;
             }
         }
@@ -161,7 +161,7 @@ static bool browser_folder_init(
             if((storage_file_get_error(directory) == FSE_OK) && (name_temp[0] != '\0')) {
                 total_files_cnt++;
                 furi_string_set(name_str, name_temp);
-                if(browser_filter_by_name(browser, name_str, (file_info.flags & FSF_DIRECTORY))) {
+                if(browser_filter_by_name(browser, name_str, file_info_is_dir(&file_info))) {
                     if(!furi_string_empty(filename)) {
                         if(furi_string_cmp(name_str, filename) == 0) {
                             *file_idx = *item_cnt;
@@ -218,7 +218,7 @@ static bool browser_folder_load_chunked(
             }
             if(storage_file_get_error(directory) == FSE_OK) {
                 furi_string_set(name_str, name_temp);
-                if(browser_filter_by_name(browser, name_str, (file_info.flags & FSF_DIRECTORY))) {
+                if(browser_filter_by_name(browser, name_str, file_info_is_dir(&file_info))) {
                     items_cnt++;
                 }
             } else {
@@ -240,14 +240,14 @@ static bool browser_folder_load_chunked(
             }
             if(storage_file_get_error(directory) == FSE_OK) {
                 furi_string_set(name_str, name_temp);
-                if(browser_filter_by_name(browser, name_str, (file_info.flags & FSF_DIRECTORY))) {
+                if(browser_filter_by_name(browser, name_str, file_info_is_dir(&file_info))) {
                     furi_string_printf(name_str, "%s/%s", furi_string_get_cstr(path), name_temp);
                     if(browser->list_item_cb) {
                         browser->list_item_cb(
                             browser->cb_ctx,
                             name_str,
                             items_cnt,
-                            (file_info.flags & FSF_DIRECTORY),
+                            file_info_is_dir(&file_info),
                             false);
                     }
                     items_cnt++;
@@ -295,15 +295,11 @@ static bool browser_folder_load_full(BrowserWorker* browser, FuriString* path) {
         while(storage_dir_read(directory, &file_info, name_temp, FILE_NAME_LEN_MAX) &&
               storage_file_get_error(directory) == FSE_OK) {
             furi_string_set(name_str, name_temp);
-            if(browser_filter_by_name(browser, name_str, (file_info.flags & FSF_DIRECTORY))) {
+            if(browser_filter_by_name(browser, name_str, file_info_is_dir(&file_info))) {
                 furi_string_printf(name_str, "%s/%s", furi_string_get_cstr(path), name_temp);
                 if(browser->list_item_cb) {
                     browser->list_item_cb(
-                        browser->cb_ctx,
-                        name_str,
-                        items_cnt,
-                        (file_info.flags & FSF_DIRECTORY),
-                        false);
+                        browser->cb_ctx, name_str, items_cnt, file_info_is_dir(&file_info), false);
                 }
                 items_cnt++;
             }
diff --git a/applications/services/gui/modules/widget.h b/applications/services/gui/modules/widget.h
index a78c4ce06a..f86b14cc9e 100644
--- a/applications/services/gui/modules/widget.h
+++ b/applications/services/gui/modules/widget.h
@@ -115,6 +115,7 @@ void widget_add_text_box_element(
  * @param[in]  text             Formatted text. Default format: align left, Secondary font.
  *                              The following formats are available:
  *                               "\e#Bold text" - sets bold font before until next '\n' symbol
+ *                               "\e*Monospaced text\e*" - sets monospaced font before until next '\n' symbol
  *                               "\ecCenter-aligned text" - sets center horizontal align until the next '\n' symbol
  *                               "\erRight-aligned text" - sets right horizontal align until the next '\n' symbol
  */
diff --git a/applications/services/gui/modules/widget_elements/widget_element_text_scroll.c b/applications/services/gui/modules/widget_elements/widget_element_text_scroll.c
index 5d522c74bf..4c9c39dffb 100644
--- a/applications/services/gui/modules/widget_elements/widget_element_text_scroll.c
+++ b/applications/services/gui/modules/widget_elements/widget_element_text_scroll.c
@@ -37,6 +37,8 @@ static bool
             line->horizontal = AlignRight;
         } else if(ctrl_symbol == '#') {
             line->font = FontPrimary;
+        } else if(ctrl_symbol == '*') {
+            line->font = FontKeyboard;
         }
         furi_string_right(text, 2);
         processed = true;
diff --git a/applications/services/loader/loader.c b/applications/services/loader/loader.c
index caaf9f11b5..5f2d8a2e73 100644
--- a/applications/services/loader/loader.c
+++ b/applications/services/loader/loader.c
@@ -29,6 +29,8 @@ static bool
     }
 
     furi_thread_set_name(loader_instance->application_thread, loader_instance->application->name);
+    furi_thread_set_appid(
+        loader_instance->application_thread, loader_instance->application->appid);
     furi_thread_set_stack_size(
         loader_instance->application_thread, loader_instance->application->stack_size);
     furi_thread_set_context(
diff --git a/applications/services/rpc/rpc_storage.c b/applications/services/rpc/rpc_storage.c
index c4493cc74e..c3a4a04704 100644
--- a/applications/services/rpc/rpc_storage.c
+++ b/applications/services/rpc/rpc_storage.c
@@ -201,7 +201,7 @@ static void rpc_system_storage_stat_process(const PB_Main* request, void* contex
     if(error == FSE_OK) {
         response->which_content = PB_Main_storage_stat_response_tag;
         response->content.storage_stat_response.has_file = true;
-        response->content.storage_stat_response.file.type = (fileinfo.flags & FSF_DIRECTORY) ?
+        response->content.storage_stat_response.file.type = file_info_is_dir(&fileinfo) ?
                                                                 PB_Storage_File_FileType_DIR :
                                                                 PB_Storage_File_FileType_FILE;
         response->content.storage_stat_response.file.size = fileinfo.size;
@@ -291,9 +291,8 @@ static void rpc_system_storage_list_process(const PB_Main* request, void* contex
                     rpc_send_and_release(session, &response);
                     i = 0;
                 }
-                list->file[i].type = (fileinfo.flags & FSF_DIRECTORY) ?
-                                         PB_Storage_File_FileType_DIR :
-                                         PB_Storage_File_FileType_FILE;
+                list->file[i].type = file_info_is_dir(&fileinfo) ? PB_Storage_File_FileType_DIR :
+                                                                   PB_Storage_File_FileType_FILE;
                 list->file[i].size = fileinfo.size;
                 list->file[i].data = NULL;
                 list->file[i].name = name;
@@ -458,7 +457,7 @@ static bool rpc_system_storage_is_dir_is_empty(Storage* fs_api, const char* path
     FileInfo fileinfo;
     bool is_dir_is_empty = true;
     FS_Error error = storage_common_stat(fs_api, path, &fileinfo);
-    if((error == FSE_OK) && (fileinfo.flags & FSF_DIRECTORY)) {
+    if((error == FSE_OK) && file_info_is_dir(&fileinfo)) {
         File* dir = storage_file_alloc(fs_api);
         if(storage_dir_open(dir, path)) {
             char* name = malloc(MAX_NAME_LENGTH);
diff --git a/applications/services/storage/filesystem_api.c b/applications/services/storage/filesystem_api.c
index b979967acb..30b20ede4d 100644
--- a/applications/services/storage/filesystem_api.c
+++ b/applications/services/storage/filesystem_api.c
@@ -36,3 +36,7 @@ const char* filesystem_api_error_get_desc(FS_Error error_id) {
     }
     return result;
 }
+
+bool file_info_is_dir(const FileInfo* file_info) {
+    return (file_info->flags & FSF_DIRECTORY);
+}
\ No newline at end of file
diff --git a/applications/services/storage/filesystem_api_defines.h b/applications/services/storage/filesystem_api_defines.h
index b73e6eb33d..cd24b88253 100644
--- a/applications/services/storage/filesystem_api_defines.h
+++ b/applications/services/storage/filesystem_api_defines.h
@@ -1,5 +1,6 @@
 #pragma once
 #include <stdint.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -40,10 +41,10 @@ typedef enum {
     FSF_DIRECTORY = (1 << 0), /**< Directory */
 } FS_Flags;
 
-/**  Structure that hold file index and returned api errors  */
+/** Structure that hold file index and returned api errors  */
 typedef struct File File;
 
-/**  Structure that hold file info */
+/** Structure that hold file info */
 typedef struct {
     uint8_t flags; /**< flags from FS_Flags enum */
     uint64_t size; /**< file size */
@@ -55,6 +56,12 @@ typedef struct {
  */
 const char* filesystem_api_error_get_desc(FS_Error error_id);
 
+/** Checks if file info is directory
+ * @param file_info file info pointer
+ * @return bool is directory
+ */
+bool file_info_is_dir(const FileInfo* file_info);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/applications/services/storage/storage.h b/applications/services/storage/storage.h
index df85a40b8f..da583ce509 100644
--- a/applications/services/storage/storage.h
+++ b/applications/services/storage/storage.h
@@ -10,10 +10,12 @@ extern "C" {
 #define STORAGE_INT_PATH_PREFIX "/int"
 #define STORAGE_EXT_PATH_PREFIX "/ext"
 #define STORAGE_ANY_PATH_PREFIX "/any"
+#define STORAGE_APP_DATA_PATH_PREFIX "/app"
 
 #define INT_PATH(path) STORAGE_INT_PATH_PREFIX "/" path
 #define EXT_PATH(path) STORAGE_EXT_PATH_PREFIX "/" path
 #define ANY_PATH(path) STORAGE_ANY_PATH_PREFIX "/" path
+#define APP_DATA_PATH(path) STORAGE_APP_DATA_PATH_PREFIX "/" path
 
 #define RECORD_STORAGE "storage"
 
@@ -175,6 +177,15 @@ bool storage_dir_read(File* file, FileInfo* fileinfo, char* name, uint16_t name_
  */
 bool storage_dir_rewind(File* file);
 
+/**
+ * @brief Check that dir exists
+ * 
+ * @param storage 
+ * @param path 
+ * @return bool 
+ */
+bool storage_dir_exists(Storage* storage, const char* path);
+
 /******************* Common Functions *******************/
 
 /** Retrieves unix timestamp of last access
@@ -246,6 +257,36 @@ FS_Error storage_common_fs_info(
     uint64_t* total_space,
     uint64_t* free_space);
 
+/**
+ * @brief Parse aliases in path and replace them with real path
+ * Also will create special folders if they are not exist
+ * 
+ * @param storage 
+ * @param path 
+ * @return bool 
+ */
+void storage_common_resolve_path_and_ensure_app_directory(Storage* storage, FuriString* path);
+
+/**
+ * @brief Move content of one folder to another, with rename of all conflicting files. 
+ * Source folder will be deleted if the migration is successful.
+ * 
+ * @param storage 
+ * @param source 
+ * @param dest 
+ * @return FS_Error 
+ */
+FS_Error storage_common_migrate(Storage* storage, const char* source, const char* dest);
+
+/**
+ * @brief Check that file or dir exists
+ * 
+ * @param storage 
+ * @param path 
+ * @return bool 
+ */
+bool storage_common_exists(Storage* storage, const char* path);
+
 /******************* Error Functions *******************/
 
 /** Retrieves the error text from the error id
diff --git a/applications/services/storage/storage_cli.c b/applications/services/storage/storage_cli.c
index ff20556977..8e2dcdbbbd 100644
--- a/applications/services/storage/storage_cli.c
+++ b/applications/services/storage/storage_cli.c
@@ -131,7 +131,7 @@ static void storage_cli_list(Cli* cli, FuriString* path) {
 
             while(storage_dir_read(file, &fileinfo, name, MAX_NAME_LENGTH)) {
                 read_done = true;
-                if(fileinfo.flags & FSF_DIRECTORY) {
+                if(file_info_is_dir(&fileinfo)) {
                     printf("\t[D] %s\r\n", name);
                 } else {
                     printf("\t[F] %s %lub\r\n", name, (uint32_t)(fileinfo.size));
@@ -169,7 +169,7 @@ static void storage_cli_tree(Cli* cli, FuriString* path) {
 
             while(dir_walk_read(dir_walk, name, &fileinfo) == DirWalkOK) {
                 read_done = true;
-                if(fileinfo.flags & FSF_DIRECTORY) {
+                if(file_info_is_dir(&fileinfo)) {
                     printf("\t[D] %s\r\n", furi_string_get_cstr(name));
                 } else {
                     printf(
@@ -383,7 +383,7 @@ static void storage_cli_stat(Cli* cli, FuriString* path) {
         FS_Error error = storage_common_stat(api, furi_string_get_cstr(path), &fileinfo);
 
         if(error == FSE_OK) {
-            if(fileinfo.flags & FSF_DIRECTORY) {
+            if(file_info_is_dir(&fileinfo)) {
                 printf("Directory\r\n");
             } else {
                 printf("File, size: %lub\r\n", (uint32_t)(fileinfo.size));
diff --git a/applications/services/storage/storage_external_api.c b/applications/services/storage/storage_external_api.c
index c5dfd533ee..8d8220f816 100644
--- a/applications/services/storage/storage_external_api.c
+++ b/applications/services/storage/storage_external_api.c
@@ -39,12 +39,6 @@
             .file = file, \
         }};
 
-#define S_API_DATA_PATH   \
-    SAData data = {       \
-        .path = {         \
-            .path = path, \
-        }};
-
 #define S_RETURN_BOOL (return_data.bool_value);
 #define S_RETURN_UINT16 (return_data.uint16_value);
 #define S_RETURN_UINT64 (return_data.uint64_value);
@@ -70,6 +64,7 @@ static bool storage_file_open_internal(
             .path = path,
             .access_mode = access_mode,
             .open_mode = open_mode,
+            .thread_id = furi_thread_get_current_id(),
         }};
 
     file->type = FileTypeOpenFile;
@@ -249,7 +244,7 @@ bool storage_file_exists(Storage* storage, const char* path) {
     FileInfo fileinfo;
     FS_Error error = storage_common_stat(storage, path, &fileinfo);
 
-    if(error == FSE_OK && !(fileinfo.flags & FSF_DIRECTORY)) {
+    if(error == FSE_OK && !file_info_is_dir(&fileinfo)) {
         exist = true;
     }
 
@@ -266,6 +261,7 @@ static bool storage_dir_open_internal(File* file, const char* path) {
         .dopen = {
             .file = file,
             .path = path,
+            .thread_id = furi_thread_get_current_id(),
         }};
 
     file->type = FileTypeOpenDir;
@@ -349,12 +345,28 @@ bool storage_dir_rewind(File* file) {
     return S_RETURN_BOOL;
 }
 
+bool storage_dir_exists(Storage* storage, const char* path) {
+    bool exist = false;
+    FileInfo fileinfo;
+    FS_Error error = storage_common_stat(storage, path, &fileinfo);
+
+    if(error == FSE_OK && file_info_is_dir(&fileinfo)) {
+        exist = true;
+    }
+
+    return exist;
+}
 /****************** COMMON ******************/
 
 FS_Error storage_common_timestamp(Storage* storage, const char* path, uint32_t* timestamp) {
     S_API_PROLOGUE;
 
-    SAData data = {.ctimestamp = {.path = path, .timestamp = timestamp}};
+    SAData data = {
+        .ctimestamp = {
+            .path = path,
+            .timestamp = timestamp,
+            .thread_id = furi_thread_get_current_id(),
+        }};
 
     S_API_MESSAGE(StorageCommandCommonTimestamp);
     S_API_EPILOGUE;
@@ -363,8 +375,12 @@ FS_Error storage_common_timestamp(Storage* storage, const char* path, uint32_t*
 
 FS_Error storage_common_stat(Storage* storage, const char* path, FileInfo* fileinfo) {
     S_API_PROLOGUE;
-
-    SAData data = {.cstat = {.path = path, .fileinfo = fileinfo}};
+    SAData data = {
+        .cstat = {
+            .path = path,
+            .fileinfo = fileinfo,
+            .thread_id = furi_thread_get_current_id(),
+        }};
 
     S_API_MESSAGE(StorageCommandCommonStat);
     S_API_EPILOGUE;
@@ -373,7 +389,12 @@ FS_Error storage_common_stat(Storage* storage, const char* path, FileInfo* filei
 
 FS_Error storage_common_remove(Storage* storage, const char* path) {
     S_API_PROLOGUE;
-    S_API_DATA_PATH;
+    SAData data = {
+        .path = {
+            .path = path,
+            .thread_id = furi_thread_get_current_id(),
+        }};
+
     S_API_MESSAGE(StorageCommandCommonRemove);
     S_API_EPILOGUE;
     return S_RETURN_ERROR;
@@ -423,7 +444,7 @@ static FS_Error
                 furi_string_right(path, strlen(old_path));
                 furi_string_printf(tmp_new_path, "%s%s", new_path, furi_string_get_cstr(path));
 
-                if(fileinfo.flags & FSF_DIRECTORY) {
+                if(file_info_is_dir(&fileinfo)) {
                     error = storage_common_mkdir(storage, furi_string_get_cstr(tmp_new_path));
                 } else {
                     error = storage_common_copy(
@@ -452,7 +473,7 @@ FS_Error storage_common_copy(Storage* storage, const char* old_path, const char*
     error = storage_common_stat(storage, old_path, &fileinfo);
 
     if(error == FSE_OK) {
-        if(fileinfo.flags & FSF_DIRECTORY) {
+        if(file_info_is_dir(&fileinfo)) {
             error = storage_copy_recursive(storage, old_path, new_path);
         } else {
             Stream* stream_from = file_stream_alloc(storage);
@@ -479,7 +500,7 @@ FS_Error storage_common_copy(Storage* storage, const char* old_path, const char*
 
 static FS_Error
     storage_merge_recursive(Storage* storage, const char* old_path, const char* new_path) {
-    FS_Error error = storage_common_mkdir(storage, new_path);
+    FS_Error error = FSE_OK;
     DirWalk* dir_walk = dir_walk_alloc(storage);
     FuriString *path, *file_basename, *tmp_new_path;
     FileInfo fileinfo;
@@ -488,7 +509,7 @@ static FS_Error
     tmp_new_path = furi_string_alloc();
 
     do {
-        if((error != FSE_OK) && (error != FSE_EXIST)) break;
+        if(!storage_simply_mkdir(storage, new_path)) break;
 
         dir_walk_set_recursive(dir_walk, false);
         if(!dir_walk_open(dir_walk, old_path)) {
@@ -508,13 +529,13 @@ static FS_Error
                 path_extract_basename(furi_string_get_cstr(path), file_basename);
                 path_concat(new_path, furi_string_get_cstr(file_basename), tmp_new_path);
 
-                if(fileinfo.flags & FSF_DIRECTORY) {
+                if(file_info_is_dir(&fileinfo)) {
                     if(storage_common_stat(
                            storage, furi_string_get_cstr(tmp_new_path), &fileinfo) == FSE_OK) {
-                        if(fileinfo.flags & FSF_DIRECTORY) {
+                        if(file_info_is_dir(&fileinfo)) {
                             error =
                                 storage_common_mkdir(storage, furi_string_get_cstr(tmp_new_path));
-                            if(error != FSE_OK) {
+                            if(error != FSE_OK && error != FSE_EXIST) {
                                 break;
                             }
                         }
@@ -548,7 +569,7 @@ FS_Error storage_common_merge(Storage* storage, const char* old_path, const char
     error = storage_common_stat(storage, old_path, &fileinfo);
 
     if(error == FSE_OK) {
-        if(fileinfo.flags & FSF_DIRECTORY) {
+        if(file_info_is_dir(&fileinfo)) {
             error = storage_merge_recursive(storage, old_path, new_path);
         } else {
             error = storage_common_stat(storage, new_path, &fileinfo);
@@ -556,7 +577,7 @@ FS_Error storage_common_merge(Storage* storage, const char* old_path, const char
                 furi_string_set(new_path_next, new_path);
                 FuriString* dir_path;
                 FuriString* filename;
-                char extension[MAX_EXT_LEN];
+                char extension[MAX_EXT_LEN] = {0};
 
                 dir_path = furi_string_alloc();
                 filename = furi_string_alloc();
@@ -608,7 +629,12 @@ FS_Error storage_common_merge(Storage* storage, const char* old_path, const char
 
 FS_Error storage_common_mkdir(Storage* storage, const char* path) {
     S_API_PROLOGUE;
-    S_API_DATA_PATH;
+    SAData data = {
+        .path = {
+            .path = path,
+            .thread_id = furi_thread_get_current_id(),
+        }};
+
     S_API_MESSAGE(StorageCommandCommonMkDir);
     S_API_EPILOGUE;
     return S_RETURN_ERROR;
@@ -626,6 +652,7 @@ FS_Error storage_common_fs_info(
             .fs_path = fs_path,
             .total_space = total_space,
             .free_space = free_space,
+            .thread_id = furi_thread_get_current_id(),
         }};
 
     S_API_MESSAGE(StorageCommandCommonFSInfo);
@@ -633,6 +660,38 @@ FS_Error storage_common_fs_info(
     return S_RETURN_ERROR;
 }
 
+void storage_common_resolve_path_and_ensure_app_directory(Storage* storage, FuriString* path) {
+    S_API_PROLOGUE;
+
+    SAData data = {
+        .cresolvepath = {
+            .path = path,
+            .thread_id = furi_thread_get_current_id(),
+        }};
+
+    S_API_MESSAGE(StorageCommandCommonResolvePath);
+    S_API_EPILOGUE;
+}
+
+FS_Error storage_common_migrate(Storage* storage, const char* source, const char* dest) {
+    if(!storage_common_exists(storage, source)) {
+        return FSE_OK;
+    }
+
+    FS_Error error = storage_common_merge(storage, source, dest);
+
+    if(error == FSE_OK) {
+        storage_simply_remove_recursive(storage, source);
+    }
+
+    return error;
+}
+
+bool storage_common_exists(Storage* storage, const char* path) {
+    FileInfo file_info;
+    return storage_common_stat(storage, path, &file_info) == FSE_OK;
+}
+
 /****************** ERROR ******************/
 
 const char* storage_error_get_desc(FS_Error error_id) {
@@ -750,7 +809,7 @@ bool storage_simply_remove_recursive(Storage* storage, const char* path) {
         }
 
         while(storage_dir_read(dir, &fileinfo, name, MAX_NAME_LENGTH)) {
-            if(fileinfo.flags & FSF_DIRECTORY) {
+            if(file_info_is_dir(&fileinfo)) {
                 furi_string_cat_printf(cur_dir, "/%s", name);
                 go_deeper = true;
                 break;
diff --git a/applications/services/storage/storage_glue.c b/applications/services/storage/storage_glue.c
index cccf4046ad..5dabfa3860 100644
--- a/applications/services/storage/storage_glue.c
+++ b/applications/services/storage/storage_glue.c
@@ -5,21 +5,18 @@
 
 void storage_file_init(StorageFile* obj) {
     obj->file = NULL;
-    obj->type = ST_ERROR;
     obj->file_data = NULL;
     obj->path = furi_string_alloc();
 }
 
 void storage_file_init_set(StorageFile* obj, const StorageFile* src) {
     obj->file = src->file;
-    obj->type = src->type;
     obj->file_data = src->file_data;
     obj->path = furi_string_alloc_set(src->path);
 }
 
 void storage_file_set(StorageFile* obj, const StorageFile* src) { //-V524
     obj->file = src->file;
-    obj->type = src->type;
     obj->file_data = src->file_data;
     furi_string_set(obj->path, src->path);
 }
@@ -150,16 +147,10 @@ void* storage_get_storage_file_data(const File* file, StorageData* storage) {
     return founded_file->file_data;
 }
 
-void storage_push_storage_file(
-    File* file,
-    FuriString* path,
-    StorageType type,
-    StorageData* storage) {
+void storage_push_storage_file(File* file, FuriString* path, StorageData* storage) {
     StorageFile* storage_file = StorageFileList_push_new(storage->files);
-
     file->file_id = (uint32_t)storage_file;
     storage_file->file = file;
-    storage_file->type = type;
     furi_string_set(storage_file->path, path);
 }
 
diff --git a/applications/services/storage/storage_glue.h b/applications/services/storage/storage_glue.h
index 501c26abcc..bf0a1c69ed 100644
--- a/applications/services/storage/storage_glue.h
+++ b/applications/services/storage/storage_glue.h
@@ -18,7 +18,6 @@ typedef struct {
 
 typedef struct {
     File* file;
-    StorageType type;
     void* file_data;
     FuriString* path;
 } StorageFile;
@@ -66,11 +65,7 @@ bool storage_path_already_open(FuriString* path, StorageFileList_t files);
 void storage_set_storage_file_data(const File* file, void* file_data, StorageData* storage);
 void* storage_get_storage_file_data(const File* file, StorageData* storage);
 
-void storage_push_storage_file(
-    File* file,
-    FuriString* path,
-    StorageType type,
-    StorageData* storage);
+void storage_push_storage_file(File* file, FuriString* path, StorageData* storage);
 bool storage_pop_storage_file(File* file, StorageData* storage);
 
 #ifdef __cplusplus
diff --git a/applications/services/storage/storage_i.h b/applications/services/storage/storage_i.h
index 406fc921ef..85df5d9265 100644
--- a/applications/services/storage/storage_i.h
+++ b/applications/services/storage/storage_i.h
@@ -12,6 +12,8 @@ extern "C" {
 
 #define STORAGE_COUNT (ST_INT + 1)
 
+#define APPS_DATA_PATH EXT_PATH("apps_data")
+
 typedef struct {
     ViewPort* view_port;
     bool enabled;
diff --git a/applications/services/storage/storage_message.h b/applications/services/storage/storage_message.h
index 3edb1018e1..9e13bf83d5 100644
--- a/applications/services/storage/storage_message.h
+++ b/applications/services/storage/storage_message.h
@@ -11,6 +11,7 @@ typedef struct {
     const char* path;
     FS_AccessMode access_mode;
     FS_OpenMode open_mode;
+    FuriThreadId thread_id;
 } SADataFOpen;
 
 typedef struct {
@@ -34,6 +35,7 @@ typedef struct {
 typedef struct {
     File* file;
     const char* path;
+    FuriThreadId thread_id;
 } SADataDOpen;
 
 typedef struct {
@@ -46,25 +48,34 @@ typedef struct {
 typedef struct {
     const char* path;
     uint32_t* timestamp;
+    FuriThreadId thread_id;
 } SADataCTimestamp;
 
 typedef struct {
     const char* path;
     FileInfo* fileinfo;
+    FuriThreadId thread_id;
 } SADataCStat;
 
 typedef struct {
     const char* fs_path;
     uint64_t* total_space;
     uint64_t* free_space;
+    FuriThreadId thread_id;
 } SADataCFSInfo;
 
+typedef struct {
+    FuriString* path;
+    FuriThreadId thread_id;
+} SADataCResolvePath;
+
 typedef struct {
     uint32_t id;
 } SADataError;
 
 typedef struct {
     const char* path;
+    FuriThreadId thread_id;
 } SADataPath;
 
 typedef struct {
@@ -87,6 +98,7 @@ typedef union {
     SADataCTimestamp ctimestamp;
     SADataCStat cstat;
     SADataCFSInfo cfsinfo;
+    SADataCResolvePath cresolvepath;
 
     SADataError error;
 
@@ -128,6 +140,7 @@ typedef enum {
     StorageCommandSDUnmount,
     StorageCommandSDInfo,
     StorageCommandSDStatus,
+    StorageCommandCommonResolvePath,
 } StorageCommand;
 
 typedef struct {
diff --git a/applications/services/storage/storage_processing.c b/applications/services/storage/storage_processing.c
index b1ea5d29b7..cab1edff58 100644
--- a/applications/services/storage/storage_processing.c
+++ b/applications/services/storage/storage_processing.c
@@ -4,17 +4,11 @@
 
 #define FS_CALL(_storage, _fn) ret = _storage->fs_api->_fn;
 
-static StorageData* storage_get_storage_by_type(Storage* app, StorageType type) {
-    furi_check(type == ST_EXT || type == ST_INT);
-    StorageData* storage = &app->storage[type];
-    return storage;
-}
-
-static bool storage_type_is_not_valid(StorageType type) {
+static bool storage_type_is_valid(StorageType type) {
 #ifdef FURI_RAM_EXEC
-    return type != ST_EXT;
+    return type == ST_EXT;
 #else
-    return type >= ST_ERROR;
+    return type < ST_ERROR;
 #endif
 }
 
@@ -30,27 +24,23 @@ static StorageData* get_storage_by_file(File* file, StorageData* storages) {
     return storage_data;
 }
 
-static const char* remove_vfs(const char* path) {
-    return path + MIN(4u, strlen(path));
+static const char* cstr_path_without_vfs_prefix(FuriString* path) {
+    const char* path_cstr = furi_string_get_cstr(path);
+    return path_cstr + MIN(4u, strlen(path_cstr));
 }
 
-static StorageType storage_get_type_by_path(Storage* app, const char* path) {
+static StorageType storage_get_type_by_path(FuriString* path) {
     StorageType type = ST_ERROR;
-    if(memcmp(path, STORAGE_EXT_PATH_PREFIX, strlen(STORAGE_EXT_PATH_PREFIX)) == 0) {
+    const char* path_cstr = furi_string_get_cstr(path);
+
+    if(memcmp(path_cstr, STORAGE_EXT_PATH_PREFIX, strlen(STORAGE_EXT_PATH_PREFIX)) == 0) {
         type = ST_EXT;
-    } else if(memcmp(path, STORAGE_INT_PATH_PREFIX, strlen(STORAGE_INT_PATH_PREFIX)) == 0) {
+    } else if(memcmp(path_cstr, STORAGE_INT_PATH_PREFIX, strlen(STORAGE_INT_PATH_PREFIX)) == 0) {
         type = ST_INT;
-    } else if(memcmp(path, STORAGE_ANY_PATH_PREFIX, strlen(STORAGE_ANY_PATH_PREFIX)) == 0) {
+    } else if(memcmp(path_cstr, STORAGE_ANY_PATH_PREFIX, strlen(STORAGE_ANY_PATH_PREFIX)) == 0) {
         type = ST_ANY;
     }
 
-    if(type == ST_ANY) {
-        type = ST_INT;
-        if(storage_data_status(&app->storage[ST_EXT]) == StorageStatusOK) {
-            type = ST_EXT;
-        }
-    }
-
     return type;
 }
 
@@ -71,38 +61,51 @@ static void storage_path_change_to_real_storage(FuriString* path, StorageType re
     }
 }
 
+FS_Error storage_get_data(Storage* app, FuriString* path, StorageData** storage) {
+    StorageType type = storage_get_type_by_path(path);
+
+    if(storage_type_is_valid(type)) {
+        if(type == ST_ANY) {
+            type = ST_INT;
+            if(storage_data_status(&app->storage[ST_EXT]) == StorageStatusOK) {
+                type = ST_EXT;
+            }
+            storage_path_change_to_real_storage(path, type);
+        }
+
+        furi_assert(type == ST_EXT || type == ST_INT);
+        *storage = &app->storage[type];
+
+        return FSE_OK;
+    } else {
+        return FSE_INVALID_NAME;
+    }
+}
+
 /******************* File Functions *******************/
 
 bool storage_process_file_open(
     Storage* app,
     File* file,
-    const char* path,
+    FuriString* path,
     FS_AccessMode access_mode,
     FS_OpenMode open_mode) {
     bool ret = false;
-    StorageType type = storage_get_type_by_path(app, path);
     StorageData* storage;
-    file->error_id = FSE_OK;
-
-    if(storage_type_is_not_valid(type)) {
-        file->error_id = FSE_INVALID_NAME;
-    } else {
-        storage = storage_get_storage_by_type(app, type);
-        FuriString* real_path;
-        real_path = furi_string_alloc_set(path);
-        storage_path_change_to_real_storage(real_path, type);
+    file->error_id = storage_get_data(app, path, &storage);
 
-        if(storage_path_already_open(real_path, storage->files)) {
+    if(file->error_id == FSE_OK) {
+        if(storage_path_already_open(path, storage->files)) {
             file->error_id = FSE_ALREADY_OPEN;
         } else {
             if(access_mode & FSAM_WRITE) {
                 storage_data_timestamp(storage);
             }
-            storage_push_storage_file(file, real_path, type, storage);
-            FS_CALL(storage, file.open(storage, file, remove_vfs(path), access_mode, open_mode));
-        }
+            storage_push_storage_file(file, path, storage);
 
-        furi_string_free(real_path);
+            const char* path_cstr_no_vfs = cstr_path_without_vfs_prefix(path);
+            FS_CALL(storage, file.open(storage, file, path_cstr_no_vfs, access_mode, open_mode));
+        }
     }
 
     return ret;
@@ -243,27 +246,18 @@ static bool storage_process_file_eof(Storage* app, File* file) {
 
 /******************* Dir Functions *******************/
 
-bool storage_process_dir_open(Storage* app, File* file, const char* path) {
+bool storage_process_dir_open(Storage* app, File* file, FuriString* path) {
     bool ret = false;
-    StorageType type = storage_get_type_by_path(app, path);
     StorageData* storage;
-    file->error_id = FSE_OK;
-
-    if(storage_type_is_not_valid(type)) {
-        file->error_id = FSE_INVALID_NAME;
-    } else {
-        storage = storage_get_storage_by_type(app, type);
-        FuriString* real_path;
-        real_path = furi_string_alloc_set(path);
-        storage_path_change_to_real_storage(real_path, type);
+    file->error_id = storage_get_data(app, path, &storage);
 
-        if(storage_path_already_open(real_path, storage->files)) {
+    if(file->error_id == FSE_OK) {
+        if(storage_path_already_open(path, storage->files)) {
             file->error_id = FSE_ALREADY_OPEN;
         } else {
-            storage_push_storage_file(file, real_path, type, storage);
-            FS_CALL(storage, dir.open(storage, file, remove_vfs(path)));
+            storage_push_storage_file(file, path, storage);
+            FS_CALL(storage, dir.open(storage, file, cstr_path_without_vfs_prefix(path)));
         }
-        furi_string_free(real_path);
     }
 
     return ret;
@@ -320,73 +314,52 @@ bool storage_process_dir_rewind(Storage* app, File* file) {
 /******************* Common FS Functions *******************/
 
 static FS_Error
-    storage_process_common_timestamp(Storage* app, const char* path, uint32_t* timestamp) {
-    FS_Error ret = FSE_OK;
-    StorageType type = storage_get_type_by_path(app, path);
+    storage_process_common_timestamp(Storage* app, FuriString* path, uint32_t* timestamp) {
+    StorageData* storage;
+    FS_Error ret = storage_get_data(app, path, &storage);
 
-    if(storage_type_is_not_valid(type)) {
-        ret = FSE_INVALID_NAME;
-    } else {
-        StorageData* storage = storage_get_storage_by_type(app, type);
+    if(ret == FSE_OK) {
         *timestamp = storage_data_get_timestamp(storage);
     }
 
     return ret;
 }
 
-static FS_Error storage_process_common_stat(Storage* app, const char* path, FileInfo* fileinfo) {
-    FS_Error ret = FSE_OK;
-    StorageType type = storage_get_type_by_path(app, path);
+static FS_Error storage_process_common_stat(Storage* app, FuriString* path, FileInfo* fileinfo) {
+    StorageData* storage;
+    FS_Error ret = storage_get_data(app, path, &storage);
 
-    if(storage_type_is_not_valid(type)) {
-        ret = FSE_INVALID_NAME;
-    } else {
-        StorageData* storage = storage_get_storage_by_type(app, type);
-        FS_CALL(storage, common.stat(storage, remove_vfs(path), fileinfo));
+    if(ret == FSE_OK) {
+        FS_CALL(storage, common.stat(storage, cstr_path_without_vfs_prefix(path), fileinfo));
     }
 
     return ret;
 }
 
-static FS_Error storage_process_common_remove(Storage* app, const char* path) {
-    FS_Error ret = FSE_OK;
-    StorageType type = storage_get_type_by_path(app, path);
-
-    FuriString* real_path;
-    real_path = furi_string_alloc_set(path);
-    storage_path_change_to_real_storage(real_path, type);
+static FS_Error storage_process_common_remove(Storage* app, FuriString* path) {
+    StorageData* storage;
+    FS_Error ret = storage_get_data(app, path, &storage);
 
     do {
-        if(storage_type_is_not_valid(type)) {
-            ret = FSE_INVALID_NAME;
-            break;
-        }
-
-        StorageData* storage = storage_get_storage_by_type(app, type);
-        if(storage_path_already_open(real_path, storage->files)) {
+        if(storage_path_already_open(path, storage->files)) {
             ret = FSE_ALREADY_OPEN;
             break;
         }
 
         storage_data_timestamp(storage);
-        FS_CALL(storage, common.remove(storage, remove_vfs(path)));
+        FS_CALL(storage, common.remove(storage, cstr_path_without_vfs_prefix(path)));
     } while(false);
 
-    furi_string_free(real_path);
-
     return ret;
 }
 
-static FS_Error storage_process_common_mkdir(Storage* app, const char* path) {
-    FS_Error ret = FSE_OK;
-    StorageType type = storage_get_type_by_path(app, path);
+static FS_Error storage_process_common_mkdir(Storage* app, FuriString* path) {
+    StorageData* storage;
+    FS_Error ret = storage_get_data(app, path, &storage);
 
-    if(storage_type_is_not_valid(type)) {
-        ret = FSE_INVALID_NAME;
-    } else {
-        StorageData* storage = storage_get_storage_by_type(app, type);
+    if(ret == FSE_OK) {
         storage_data_timestamp(storage);
-        FS_CALL(storage, common.mkdir(storage, remove_vfs(path)));
+        FS_CALL(storage, common.mkdir(storage, cstr_path_without_vfs_prefix(path)));
     }
 
     return ret;
@@ -394,17 +367,16 @@ static FS_Error storage_process_common_mkdir(Storage* app, const char* path) {
 
 static FS_Error storage_process_common_fs_info(
     Storage* app,
-    const char* fs_path,
+    FuriString* path,
     uint64_t* total_space,
     uint64_t* free_space) {
-    FS_Error ret = FSE_OK;
-    StorageType type = storage_get_type_by_path(app, fs_path);
+    StorageData* storage;
+    FS_Error ret = storage_get_data(app, path, &storage);
 
-    if(storage_type_is_not_valid(type)) {
-        ret = FSE_INVALID_NAME;
-    } else {
-        StorageData* storage = storage_get_storage_by_type(app, type);
-        FS_CALL(storage, common.fs_info(storage, remove_vfs(fs_path), total_space, free_space));
+    if(ret == FSE_OK) {
+        FS_CALL(
+            storage,
+            common.fs_info(storage, cstr_path_without_vfs_prefix(path), total_space, free_space));
     }
 
     return ret;
@@ -471,14 +443,52 @@ static FS_Error storage_process_sd_status(Storage* app) {
     return ret;
 }
 
+/******************** Aliases processing *******************/
+
+void storage_process_alias(
+    Storage* app,
+    FuriString* path,
+    FuriThreadId thread_id,
+    bool create_folders) {
+    if(furi_string_start_with(path, STORAGE_APP_DATA_PATH_PREFIX)) {
+        FuriString* apps_data_path_with_appsid = furi_string_alloc_set(APPS_DATA_PATH "/");
+        furi_string_cat(apps_data_path_with_appsid, furi_thread_get_appid(thread_id));
+
+        // "/app" -> "/ext/apps_data/appsid"
+        furi_string_replace_at(
+            path,
+            0,
+            strlen(STORAGE_APP_DATA_PATH_PREFIX),
+            furi_string_get_cstr(apps_data_path_with_appsid));
+
+        // Create app data folder if not exists
+        if(create_folders &&
+           storage_process_common_stat(app, apps_data_path_with_appsid, NULL) != FSE_OK) {
+            furi_string_set(apps_data_path_with_appsid, APPS_DATA_PATH);
+            storage_process_common_mkdir(app, apps_data_path_with_appsid);
+            furi_string_cat(apps_data_path_with_appsid, "/");
+            furi_string_cat(apps_data_path_with_appsid, furi_thread_get_appid(thread_id));
+            storage_process_common_mkdir(app, apps_data_path_with_appsid);
+        }
+
+        furi_string_free(apps_data_path_with_appsid);
+    }
+}
+
 /****************** API calls processing ******************/
+
 void storage_process_message_internal(Storage* app, StorageMessage* message) {
+    FuriString* path = NULL;
+
     switch(message->command) {
+    // File operations
     case StorageCommandFileOpen:
+        path = furi_string_alloc_set(message->data->fopen.path);
+        storage_process_alias(app, path, message->data->fopen.thread_id, true);
         message->return_data->bool_value = storage_process_file_open(
             app,
             message->data->fopen.file,
-            message->data->fopen.path,
+            path,
             message->data->fopen.access_mode,
             message->data->fopen.open_mode);
         break;
@@ -527,9 +537,12 @@ void storage_process_message_internal(Storage* app, StorageMessage* message) {
         message->return_data->bool_value = storage_process_file_eof(app, message->data->file.file);
         break;
 
+    // Dir operations
     case StorageCommandDirOpen:
+        path = furi_string_alloc_set(message->data->dopen.path);
+        storage_process_alias(app, path, message->data->dopen.thread_id, true);
         message->return_data->bool_value =
-            storage_process_dir_open(app, message->data->dopen.file, message->data->dopen.path);
+            storage_process_dir_open(app, message->data->dopen.file, path);
         break;
     case StorageCommandDirClose:
         message->return_data->bool_value =
@@ -547,29 +560,42 @@ void storage_process_message_internal(Storage* app, StorageMessage* message) {
         message->return_data->bool_value =
             storage_process_dir_rewind(app, message->data->file.file);
         break;
+
+    // Common operations
     case StorageCommandCommonTimestamp:
-        message->return_data->error_value = storage_process_common_timestamp(
-            app, message->data->ctimestamp.path, message->data->ctimestamp.timestamp);
+        path = furi_string_alloc_set(message->data->ctimestamp.path);
+        storage_process_alias(app, path, message->data->ctimestamp.thread_id, false);
+        message->return_data->error_value =
+            storage_process_common_timestamp(app, path, message->data->ctimestamp.timestamp);
         break;
     case StorageCommandCommonStat:
-        message->return_data->error_value = storage_process_common_stat(
-            app, message->data->cstat.path, message->data->cstat.fileinfo);
+        path = furi_string_alloc_set(message->data->cstat.path);
+        storage_process_alias(app, path, message->data->cstat.thread_id, false);
+        message->return_data->error_value =
+            storage_process_common_stat(app, path, message->data->cstat.fileinfo);
         break;
     case StorageCommandCommonRemove:
-        message->return_data->error_value =
-            storage_process_common_remove(app, message->data->path.path);
+        path = furi_string_alloc_set(message->data->path.path);
+        storage_process_alias(app, path, message->data->path.thread_id, false);
+        message->return_data->error_value = storage_process_common_remove(app, path);
         break;
     case StorageCommandCommonMkDir:
-        message->return_data->error_value =
-            storage_process_common_mkdir(app, message->data->path.path);
+        path = furi_string_alloc_set(message->data->path.path);
+        storage_process_alias(app, path, message->data->path.thread_id, true);
+        message->return_data->error_value = storage_process_common_mkdir(app, path);
         break;
     case StorageCommandCommonFSInfo:
+        path = furi_string_alloc_set(message->data->cfsinfo.fs_path);
+        storage_process_alias(app, path, message->data->cfsinfo.thread_id, false);
         message->return_data->error_value = storage_process_common_fs_info(
-            app,
-            message->data->cfsinfo.fs_path,
-            message->data->cfsinfo.total_space,
-            message->data->cfsinfo.free_space);
+            app, path, message->data->cfsinfo.total_space, message->data->cfsinfo.free_space);
+        break;
+    case StorageCommandCommonResolvePath:
+        storage_process_alias(
+            app, message->data->cresolvepath.path, message->data->cresolvepath.thread_id, true);
         break;
+
+    // SD operations
     case StorageCommandSDFormat:
         message->return_data->error_value = storage_process_sd_format(app);
         break;
@@ -585,6 +611,10 @@ void storage_process_message_internal(Storage* app, StorageMessage* message) {
         break;
     }
 
+    if(path != NULL) { //-V547
+        furi_string_free(path);
+    }
+
     api_lock_unlock(message->lock);
 }
 
diff --git a/applications/services/storage/storage_test_app.c b/applications/services/storage/storage_test_app.c
deleted file mode 100644
index 852953e993..0000000000
--- a/applications/services/storage/storage_test_app.c
+++ /dev/null
@@ -1,341 +0,0 @@
-#include <furi.h>
-#include <furi_hal.h>
-#include <storage/storage.h>
-
-#define TAG "StorageTest"
-#define BYTES_COUNT 16
-#define TEST_STRING "TestDataStringProvidedByDiceRoll"
-#define SEEK_OFFSET_FROM_START 10
-#define SEEK_OFFSET_INCREASE 12
-#define SEEK_OFFSET_SUM (SEEK_OFFSET_FROM_START + SEEK_OFFSET_INCREASE)
-
-static void do_file_test(Storage* api, const char* path) {
-    File* file = storage_file_alloc(api);
-    bool result;
-    uint8_t bytes[BYTES_COUNT + 1];
-    uint8_t bytes_count;
-    uint64_t position;
-    uint64_t size;
-
-    FURI_LOG_I(TAG, "--------- FILE \"%s\" ---------", path);
-
-    // open
-    result = storage_file_open(file, path, FSAM_WRITE, FSOM_CREATE_ALWAYS);
-    if(result) {
-        FURI_LOG_I(TAG, "open");
-    } else {
-        FURI_LOG_E(TAG, "open, %s", storage_file_get_error_desc(file));
-    }
-
-    // write
-    bytes_count = storage_file_write(file, TEST_STRING, strlen(TEST_STRING));
-    if(bytes_count == 0) {
-        FURI_LOG_E(TAG, "write, %s", storage_file_get_error_desc(file));
-    } else {
-        FURI_LOG_I(TAG, "write");
-    }
-
-    // sync
-    result = storage_file_sync(file);
-    if(result) {
-        FURI_LOG_I(TAG, "sync");
-    } else {
-        FURI_LOG_E(TAG, "sync, %s", storage_file_get_error_desc(file));
-    }
-
-    // eof #1
-    result = storage_file_eof(file);
-    if(result) {
-        FURI_LOG_I(TAG, "eof #1");
-    } else {
-        FURI_LOG_E(TAG, "eof #1, %s", storage_file_get_error_desc(file));
-    }
-
-    // seek from start and tell
-    result = storage_file_seek(file, SEEK_OFFSET_FROM_START, true);
-    if(result) {
-        FURI_LOG_I(TAG, "seek #1");
-    } else {
-        FURI_LOG_E(TAG, "seek #1, %s", storage_file_get_error_desc(file));
-    }
-    position = storage_file_tell(file);
-    if(position != SEEK_OFFSET_FROM_START) {
-        FURI_LOG_E(TAG, "tell #1, %s", storage_file_get_error_desc(file));
-    } else {
-        FURI_LOG_I(TAG, "tell #1");
-    }
-
-    // size
-    size = storage_file_size(file);
-    if(size != strlen(TEST_STRING)) {
-        FURI_LOG_E(TAG, "size #1, %s", storage_file_get_error_desc(file));
-    } else {
-        FURI_LOG_I(TAG, "size #1");
-    }
-
-    // seek and tell
-    result = storage_file_seek(file, SEEK_OFFSET_INCREASE, false);
-    if(result) {
-        FURI_LOG_I(TAG, "seek #2");
-    } else {
-        FURI_LOG_E(TAG, "seek #2, %s", storage_file_get_error_desc(file));
-    }
-    position = storage_file_tell(file);
-    if(position != SEEK_OFFSET_SUM) {
-        FURI_LOG_E(TAG, "tell #2, %s", storage_file_get_error_desc(file));
-    } else {
-        FURI_LOG_I(TAG, "tell #2");
-    }
-
-    // eof #2
-    result = storage_file_eof(file);
-    if(!result) {
-        FURI_LOG_I(TAG, "eof #2");
-    } else {
-        FURI_LOG_E(TAG, "eof #2, %s", storage_file_get_error_desc(file));
-    }
-
-    // truncate
-    result = storage_file_truncate(file);
-    if(result) {
-        FURI_LOG_I(TAG, "truncate");
-    } else {
-        FURI_LOG_E(TAG, "truncate, %s", storage_file_get_error_desc(file));
-    }
-    size = storage_file_size(file);
-    if(size != SEEK_OFFSET_SUM) {
-        FURI_LOG_E(TAG, "size #2, %s", storage_file_get_error_desc(file));
-    } else {
-        FURI_LOG_I(TAG, "size #2");
-    }
-
-    // close
-    result = storage_file_close(file);
-    if(result) {
-        FURI_LOG_I(TAG, "close");
-    } else {
-        FURI_LOG_E(TAG, "close, error");
-    }
-
-    // open
-    result = storage_file_open(file, path, FSAM_READ, FSOM_OPEN_EXISTING);
-    if(result) {
-        FURI_LOG_I(TAG, "open");
-    } else {
-        FURI_LOG_E(TAG, "open, %s", storage_file_get_error_desc(file));
-    }
-
-    // read
-    memset(bytes, 0, BYTES_COUNT + 1);
-    bytes_count = storage_file_read(file, bytes, BYTES_COUNT);
-    if(bytes_count == 0) {
-        FURI_LOG_E(TAG, "read, %s", storage_file_get_error_desc(file));
-    } else {
-        if(memcmp(TEST_STRING, bytes, bytes_count) == 0) {
-            FURI_LOG_I(TAG, "read");
-        } else {
-            FURI_LOG_E(TAG, "read, garbage");
-        }
-    }
-
-    // close
-    result = storage_file_close(file);
-    if(result) {
-        FURI_LOG_I(TAG, "close");
-    } else {
-        FURI_LOG_E(TAG, "close, error");
-    }
-
-    storage_file_free(file);
-}
-
-static void do_dir_test(Storage* api, const char* path) {
-    File* file = storage_file_alloc(api);
-    bool result;
-
-    FURI_LOG_I(TAG, "--------- DIR \"%s\" ---------", path);
-
-    // open
-    result = storage_dir_open(file, path);
-    if(result) {
-        FURI_LOG_I(TAG, "open");
-    } else {
-        FURI_LOG_E(TAG, "open, %s", storage_file_get_error_desc(file));
-    }
-
-    // read
-    const uint8_t filename_size = 100;
-    char* filename = malloc(filename_size);
-    FileInfo fileinfo;
-
-    do {
-        result = storage_dir_read(file, &fileinfo, filename, filename_size);
-        if(result) {
-            if(strlen(filename)) {
-                FURI_LOG_I(
-                    TAG,
-                    "read #1, [%s]%s",
-                    ((fileinfo.flags & FSF_DIRECTORY) ? "D" : "F"),
-                    filename);
-            }
-        } else if(storage_file_get_error(file) != FSE_NOT_EXIST) {
-            FURI_LOG_E(TAG, "read #1, %s", storage_file_get_error_desc(file));
-            break;
-        }
-
-    } while(result);
-
-    // rewind
-    result = storage_dir_rewind(file);
-    if(result) {
-        FURI_LOG_I(TAG, "rewind");
-    } else {
-        FURI_LOG_E(TAG, "rewind, %s", storage_file_get_error_desc(file));
-    }
-
-    // read
-    do {
-        result = storage_dir_read(file, &fileinfo, filename, filename_size);
-        if(result) {
-            if(strlen(filename)) {
-                FURI_LOG_I(
-                    TAG,
-                    "read #2, [%s]%s",
-                    ((fileinfo.flags & FSF_DIRECTORY) ? "D" : "F"),
-                    filename);
-            }
-        } else if(storage_file_get_error(file) != FSE_NOT_EXIST) {
-            FURI_LOG_E(TAG, "read #2, %s", storage_file_get_error_desc(file));
-            break;
-        }
-
-    } while((strlen(filename)));
-
-    // close
-    result = storage_dir_close(file);
-    if(result) {
-        FURI_LOG_I(TAG, "close");
-    } else {
-        FURI_LOG_E(TAG, "close, error");
-    }
-
-    storage_file_free(file);
-    free(filename);
-}
-
-static void do_test_start(Storage* api, const char* path) {
-    FuriString* str_path = furi_string_alloc_printf("%s/test-folder", path);
-
-    FURI_LOG_I(TAG, "--------- START \"%s\" ---------", path);
-
-    // mkdir
-    FS_Error result = storage_common_mkdir(api, furi_string_get_cstr(str_path));
-
-    if(result == FSE_OK) {
-        FURI_LOG_I(TAG, "mkdir ok");
-    } else {
-        FURI_LOG_E(TAG, "mkdir, %s", storage_error_get_desc(result));
-    }
-
-    // stat
-    FileInfo fileinfo;
-    result = storage_common_stat(api, furi_string_get_cstr(str_path), &fileinfo);
-
-    if(result == FSE_OK) {
-        if(fileinfo.flags & FSF_DIRECTORY) {
-            FURI_LOG_I(TAG, "stat #1 ok");
-        } else {
-            FURI_LOG_E(TAG, "stat #1, %s", storage_error_get_desc(result));
-        }
-    } else {
-        FURI_LOG_E(TAG, "stat #1, %s", storage_error_get_desc(result));
-    }
-
-    furi_string_free(str_path);
-}
-
-static void do_test_end(Storage* api, const char* path) {
-    uint64_t total_space;
-    uint64_t free_space;
-    FuriString* str_path_1 = furi_string_alloc_printf("%s/test-folder", path);
-    FuriString* str_path_2 = furi_string_alloc_printf("%s/test-folder2", path);
-
-    FURI_LOG_I(TAG, "--------- END \"%s\" ---------", path);
-
-    // fs stat
-    FS_Error result = storage_common_fs_info(api, path, &total_space, &free_space);
-
-    if(result == FSE_OK) {
-        uint32_t total_kb = total_space / 1024;
-        uint32_t free_kb = free_space / 1024;
-        FURI_LOG_I(TAG, "fs_info: total %luk, free %luk", total_kb, free_kb);
-    } else {
-        FURI_LOG_E(TAG, "fs_info, %s", storage_error_get_desc(result));
-    }
-
-    // rename #1
-    result = storage_common_rename(
-        api, furi_string_get_cstr(str_path_1), furi_string_get_cstr(str_path_2));
-    if(result == FSE_OK) {
-        FURI_LOG_I(TAG, "rename #1 ok");
-    } else {
-        FURI_LOG_E(TAG, "rename #1, %s", storage_error_get_desc(result));
-    }
-
-    // remove #1
-    result = storage_common_remove(api, furi_string_get_cstr(str_path_2));
-    if(result == FSE_OK) {
-        FURI_LOG_I(TAG, "remove #1 ok");
-    } else {
-        FURI_LOG_E(TAG, "remove #1, %s", storage_error_get_desc(result));
-    }
-
-    // rename #2
-    furi_string_printf(str_path_1, "%s/test.txt", path);
-    furi_string_printf(str_path_2, "%s/test2.txt", path);
-
-    result = storage_common_rename(
-        api, furi_string_get_cstr(str_path_1), furi_string_get_cstr(str_path_2));
-    if(result == FSE_OK) {
-        FURI_LOG_I(TAG, "rename #2 ok");
-    } else {
-        FURI_LOG_E(TAG, "rename #2, %s", storage_error_get_desc(result));
-    }
-
-    // remove #2
-    result = storage_common_remove(api, furi_string_get_cstr(str_path_2));
-    if(result == FSE_OK) {
-        FURI_LOG_I(TAG, "remove #2 ok");
-    } else {
-        FURI_LOG_E(TAG, "remove #2, %s", storage_error_get_desc(result));
-    }
-
-    furi_string_free(str_path_1);
-    furi_string_free(str_path_2);
-}
-
-int32_t storage_test_app(void* p) {
-    UNUSED(p);
-    Storage* api = furi_record_open(RECORD_STORAGE);
-    do_test_start(api, STORAGE_INT_PATH_PREFIX);
-    do_test_start(api, STORAGE_ANY_PATH_PREFIX);
-    do_test_start(api, STORAGE_EXT_PATH_PREFIX);
-
-    do_file_test(api, INT_PATH("test.txt"));
-    do_file_test(api, ANY_PATH("test.txt"));
-    do_file_test(api, EXT_PATH("test.txt"));
-
-    do_dir_test(api, STORAGE_INT_PATH_PREFIX);
-    do_dir_test(api, STORAGE_ANY_PATH_PREFIX);
-    do_dir_test(api, STORAGE_EXT_PATH_PREFIX);
-
-    do_test_end(api, STORAGE_INT_PATH_PREFIX);
-    do_test_end(api, STORAGE_ANY_PATH_PREFIX);
-    do_test_end(api, STORAGE_EXT_PATH_PREFIX);
-
-    while(true) {
-        furi_delay_ms(1000);
-    }
-
-    return 0;
-}
diff --git a/applications/system/storage_move_to_sd/storage_move_to_sd.c b/applications/system/storage_move_to_sd/storage_move_to_sd.c
index 2027bd2375..9c91b92668 100644
--- a/applications/system/storage_move_to_sd/storage_move_to_sd.c
+++ b/applications/system/storage_move_to_sd/storage_move_to_sd.c
@@ -13,7 +13,7 @@
 
 static bool storage_move_to_sd_check_entry(const char* name, FileInfo* fileinfo, void* ctx) {
     UNUSED(ctx);
-    if((fileinfo->flags & FSF_DIRECTORY) != 0) {
+    if(file_info_is_dir(fileinfo)) {
         return true;
     }
 
diff --git a/assets/icons/ErasePin/Erase_pin_128x64.png b/assets/icons/ErasePin/Erase_pin_128x64.png
new file mode 100644
index 0000000000..92ca5f91cb
Binary files /dev/null and b/assets/icons/ErasePin/Erase_pin_128x64.png differ
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_0.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_0.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_0.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_0.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_1.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_1.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_1.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_1.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_2.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_2.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_2.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_2.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_3.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_3.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_3.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_3.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_4.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_4.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_4.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_4.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_5.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_5.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_5.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_5.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_6.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_6.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_6.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_6.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_7.png b/assets/icons/MainMenu/SubGHzRemote_14/frame_7.png
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_7.png
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_7.png
diff --git a/assets/icons/MainMenu/UniRFRemix_14/frame_rate b/assets/icons/MainMenu/SubGHzRemote_14/frame_rate
similarity index 100%
rename from assets/icons/MainMenu/UniRFRemix_14/frame_rate
rename to assets/icons/MainMenu/SubGHzRemote_14/frame_rate
diff --git a/assets/resources/picopass/assets/iclass_elite_dict.txt b/assets/resources/apps_data/picopass/assets/iclass_elite_dict.txt
similarity index 98%
rename from assets/resources/picopass/assets/iclass_elite_dict.txt
rename to assets/resources/apps_data/picopass/assets/iclass_elite_dict.txt
index 46808ef602..5da2a2fa80 100644
--- a/assets/resources/picopass/assets/iclass_elite_dict.txt
+++ b/assets/resources/apps_data/picopass/assets/iclass_elite_dict.txt
@@ -45,3 +45,5 @@ C1B74D7478053AE2
 
 # default iCLASS RFIDeas
 6B65797374726B72
+
+5C100DF7042EAE64
diff --git a/assets/resources/infrared/assets/ac.ir b/assets/resources/infrared/assets/ac.ir
index 3b25a5c86b..2b69e6f689 100644
--- a/assets/resources/infrared/assets/ac.ir
+++ b/assets/resources/infrared/assets/ac.ir
@@ -1,7 +1,7 @@
 Filetype: IR library file
 Version: 1
-# Last Updated 21st Feb, 2023
-# Last Checked 21st Feb, 2023
+# Last Updated 07th Mar, 2023
+# Last Checked 07th Mar, 2023
 #
 name: POWER
 type: raw
@@ -1091,6 +1091,18 @@ type: raw
 frequency: 38000
 duty_cycle: 0.330000
 data: 270 18152 3021 8955 523 499 495 1497 492 504 500 468 526 496 498 498 496 499 495 501 493 502 492 1499 500 496 498 524 470 1521 498 497 497 499 495 1496 492 1499 500 1491 497 1494 494 1497 502 494 500 495 499 497 497 498 496 500 494 528 466 530 464 531 473 522 493 503 491 504 500 495 499 497 497 498 496 500 494 501 493 503 491 504 500 495 499 496 498 498 496 499 495 501 493 529 465 531 473 522 472 523 492 504 490 505 499 496 498 498 496 499 495 1496 492 1499 500 1492 496 1494 525 2947 2999 8953 525 1519 469 499 516 507 497 498 496 500 494 501 493 503 491 504 500 495 499 1492 496 499 495 501 493 1498 501 495 499 1492 496 1522 466 1524 496 1496 492 1499 500 1492 496 499 495 500 494 502 492 504 500 495 499 496 498 498 496 499 495 500 494 502 492 530 474 521 473 523 523 472 522 474 489 506 498 497 497 499 495 500 494 502 492 503 501 494 500 496 498 497 497 499 495 500 494 502 492 503 501 521 473 523 471 524 522 474 520 475 498 497 497 499 495 500 494 2978 2999 8952 525 1492 496 499 495 501 493 503 491 504 500 495 499 497 497 525 469 526 468 1524 516 479 494 501 493 503 491 504 500 495 499 497 497 1494 494 1497 492 1500 499 1492 496 499 495 1497 491 531 473 1518 522 1469 499 496 498 498 496 500 494 1497 491 1500 499 1492 496 499 495 501 493 502 492 504 500 495 499 523 471 525 469 526 520 1472 516 1475 493 502 492 504 500 495 499 1492 496 499 495 501 493 502 492 504 500 495 499 496 498 498 496 1522 466 1525 525 1466 491 1500 499
+# POWER_ON
+name: POWER
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 4455 4310 587 1553 587 481 588 1552 587 1553 587 482 587 483 586 1553 585 483 586 483 587 1553 586 483 586 483 585 1553 586 1553 586 483 586 1553 586 1553 586 483 586 483 585 1553 586 1553 587 1552 586 1553 585 1554 585 483 586 1552 588 1552 585 483 586 483 586 483 586 483 585 484 585 484 585 483 586 483 586 483 585 484 586 483 586 483 586 483 586 1553 585 1553 585 1554 585 1553 585 1554 585 1553 586 1553 585 1554 584 5128 4426 4312 584 1554 585 484 585 1553 585 1554 585 483 586 483 585 1554 584 484 585 484 584 1553 584 485 584 484 585 1554 584 1555 583 485 584 1552 586 1553 585 484 585 483 585 1553 583 1554 585 1553 584 1554 583 1554 584 485 584 1554 584 1554 583 484 585 484 585 484 584 484 584 485 584 484 585 484 584 485 583 485 583 484 585 484 585 484 584 485 583 1555 584 1554 584 1553 584 1553 585 1553 584 1553 585 1553 584 1555 583
+# POWER_ON
+name: POWER
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 530 374 30128 50095 3452 1625 471 1229 471 459 471 459 471 459 444 459 471 459 470 459 471 459 471 459 471 459 444 460 470 459 471 1230 470 459 470 460 443 460 470 460 469 460 470 460 470 460 443 1231 470 1230 470 460 470 460 470 460 443 487 443 460 469 460 470 461 468 461 469 1232 442 461 469 1232 468 1232 442 1232 468 1232 468 1232 468 1232 441 461 469 1232 468 1232 442 488 442 461 469 462 468 463 466 463 467 485 418 488 442 485 444 1234 467 1256 418 1256 444 1256 444 1256 444 1256 418 1256 444 1256 444 485 444 486 417 486 444 1256 444 485 444 485 444 486 417 486 444 1257 443 486 444 485 444 1257 417 486 444 486 443 486 444 1257 417 1257 443 486 444 486 444 486 443 486 417 513 416 487 443 487 442 486 444 1257 416 1257 443 487 442 486 444 486 443 487 416 513 416 487 443 486 443 487 443 487 442 487 416 514 415 1258 442 487 442 487 443 487 416 514 416 488 442 487 443 488 442 488 442 1258 415 1258 442 488 442 488 441 488 442 488 415 488 441 488 442 488 442 1259 441 1259 415 489 440 489 441 488 442 489 440 488 415 1259 441 1260 440 1260 414 516 414 489 439 491 440 489 440 490 439 490 414 516 413 490 438 491 438 492 438 491 415 539 389 517 413 514 391 516 414 539 414 516 390 539 388 542 363 540 390 1311 389 540 389 540 363 567 363 540 390 540 389 540 390 540 390 540 363 567 363 541 389 540 390 540 389 540 390 541 362 567 363 541 389 541 389 541 389 541 389 541 362 568 361 541 389 541 389 542 388 541 389 541 362 542 388 542 387 542 388 542 388 543 387 567 335 567 363 567 363 567 363 567 363 567 336 594 335 568 362 567 362 568 361 568 362 567 336 595 335 568 362 568 361 568 362 1338 362 1339 334 569 361 569 360 569 361 569 360 569 334 570 360 570 360 595 334 595 334 1366 307 1366 334 595 335 595 335 595 335 596 306 623 307 596 334 596 333 597 333 622 307 597 306 597 333 623 306 623 306 624 306 624 306 624 278 1395 305 1395 305 650 279 651 360
 #
 name: TEMP+
 type: raw
@@ -1572,3 +1584,99 @@ type: raw
 frequency: 38000
 duty_cycle: 0.330000
 data: 8362 4223 595 1983 1116 1480 592 1987 1081 1567 1070 1524 550 2029 1043 1540 1042 1568 1043 1532 549 2030 1042 1540 1042 1568 1042 1532 1042 1532 549 2022 549 2065 1043 1528 1043 1532 1043 1524 1042 1576 1042 1532 1042 1525 548 2030 549 2082 1042 1524 1042 1533 1042 1525 1042 1576 1042 1533 1042 1525 1041 1533 1042 1569 1042 1533 1042 1533 1042 1525 1041 1577 1041 1533 1042 1525 1041 1534 1041 1569 1042 1533 1041 1534 1040 1526 1041 1578 1041 1534 1041 1526 1040 1534 1041 1570 1041 1534 1015 1560 1015 1552 1015 1604 1040 1535 1040 1527 1039 1535 1014 1597 1013 1561 1014 1561 1013 1554 519 2129 987 1554 544 2036 518 2093 987
+# POWER_OFF
+name: POWER
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 4453 4313 586 1554 585 483 586 1554 587 1552 587 483 587 484 586 1552 587 482 588 483 586 1553 586 483 587 483 586 1554 586 1553 585 484 587 1553 586 484 587 1553 586 1554 586 1553 586 1554 586 483 586 1553 586 1553 586 1555 585 483 586 482 588 483 585 484 585 1554 586 483 587 484 585 1553 587 1554 584 1554 585 484 586 484 586 483 586 483 586 484 586 482 588 483 584 484 586 1553 585 1555 584 1555 586 1553 586 1554 585 5129 4428 4312 585 1553 586 483 586 1555 584 1553 586 484 583 486 584 1555 585 484 585 483 586 1554 585 483 586 484 585 1554 585 1554 585 484 585 1554 585 484 584 1554 585 1554 584 1554 585 1554 586 483 585 1554 585 1555 584 1553 584 484 586 483 586 483 585 484 586 1554 583 484 586 483 585 1553 585 1553 585 1553 585 484 584 485 585 485 584 484 585 484 585 485 584 484 585 483 586 1554 585 1553 585 1554 584 1553 585 1553 585
+# TEMP_17
+name: TEMP-
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 4459 4311 588 1552 588 482 588 1552 589 1552 588 481 589 481 589 1552 588 482 587 483 587 1553 587 482 588 481 589 1553 588 1552 588 482 587 1554 586 483 587 1553 587 482 588 1552 588 1553 587 1553 588 1552 588 1552 588 1553 587 482 587 1553 588 481 589 482 587 482 587 483 587 482 587 483 588 482 587 483 587 482 587 483 587 482 587 483 586 483 587 1553 587 1553 587 1553 587 1554 586 1553 588 1553 587 1554 587 1553 587 5130 4431 4314 586 1553 588 482 588 1553 586 1554 587 483 587 483 587 1553 587 483 587 483 586 1554 587 483 586 483 587 1553 587 1553 587 482 588 1553 587 482 587 1553 587 483 587 1553 587 1554 586 1554 586 1554 586 1553 587 1554 587 482 588 1553 587 483 586 484 586 483 586 483 587 483 587 483 587 483 586 483 586 483 587 483 586 484 586 483 587 483 586 1554 586 1554 586 1554 586 1554 586 1554 586 1554 586 1555 586 1554 586
+# TEMP_30
+name: TEMP+
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 4489 4254 647 1493 645 425 619 1521 619 1521 619 452 617 453 616 1526 613 478 591 479 590 1551 589 481 588 481 589 1552 588 1552 588 482 588 1552 588 482 588 1552 588 482 588 1552 588 1553 587 1553 587 1552 588 1553 588 1552 588 482 588 1553 587 482 588 482 588 482 588 482 588 482 588 1552 588 482 588 1552 588 1552 588 482 588 482 588 482 588 482 588 482 588 1553 587 482 588 482 588 1553 587 1553 587 1553 587 1553 587 5130 4432 4313 587 1553 587 483 587 1553 587 1553 587 483 587 483 587 1553 587 483 587 483 587 1553 587 483 587 483 587 1553 587 1554 586 483 586 1553 587 483 587 1553 587 483 587 1553 587 1553 587 1554 586 1554 586 1554 586 1554 587 483 587 1553 587 483 587 483 587 483 587 483 587 483 587 1554 586 483 587 1554 586 1554 586 483 587 483 587 483 587 483 586 484 586 1554 586 484 586 483 587 1554 586 1554 586 1554 586 1554 586
+# POWER_OFF
+name: POWER
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 479 397 30131 50087 3427 1674 447 1253 447 483 446 483 446 483 420 483 447 483 447 483 447 483 447 483 420 510 419 483 447 483 446 1254 446 483 420 510 419 484 446 483 447 484 445 483 446 484 419 1255 445 1254 446 484 445 484 445 484 419 484 446 484 446 484 445 484 446 484 445 1255 418 484 446 1255 445 1255 418 1255 445 1255 445 1254 446 1255 419 484 446 1255 445 1255 418 511 418 485 445 484 445 484 446 484 445 485 418 511 418 484 446 1255 445 1255 418 1255 445 1255 444 1256 444 1256 417 1256 445 1255 443 487 418 511 419 485 444 1255 445 485 445 485 420 509 418 485 445 1255 445 485 444 485 445 1256 417 512 418 485 444 485 445 1256 417 1256 444 485 444 485 420 509 444 486 418 511 418 485 445 485 444 1256 444 486 418 512 417 485 420 509 445 485 445 485 445 485 417 1256 444 486 444 485 445 1256 417 1256 443 486 444 485 444 486 444 485 444 485 418 485 444 485 444 485 444 486 443 486 417 1257 420 509 420 510 444 485 444 486 444 485 418 485 445 485 443 487 444 1256 444 1256 417 485 442 487 420 510 444 485 444 486 417 1256 420 1280 443 1257 417 512 393 510 444 486 442 487 443 486 419 510 417 513 419 484 419 510 444 486 419 510 419 510 393 537 415 488 420 510 418 510 419 510 419 510 392 537 392 511 445 484 419 511 418 511 418 511 392 538 391 511 419 511 419 511 418 511 418 511 391 511 419 512 418 511 418 511 419 511 418 512 391 512 418 512 417 512 417 512 418 512 417 512 391 512 418 512 417 512 417 512 417 512 391 539 390 513 416 513 417 512 417 513 417 537 366 564 365 514 416 537 392 537 392 538 392 538 365 564 365 538 392 538 392 538 391 538 391 538 365 564 365 538 392 538 391 1309 391 1308 365 538 391 538 392 538 391 538 392 538 365 565 364 538 392 538 391 539 391 1309 364 1309 391 538 391 539 391 538 391 538 391 539 364 538 392 539 390 539 391 539 390 539 364 565 364 539 391 539 390 1309 391 539 390 1309 364 539 391 539 390 539 391 539 498
+# 
+name: MODE
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 479 396 30132 50085 3427 1674 446 1254 446 483 446 483 446 483 420 483 446 483 447 483 446 483 446 483 420 510 419 483 446 483 446 1254 446 483 420 510 419 483 446 484 446 483 446 484 446 483 420 1254 446 1254 446 484 445 484 446 483 420 484 446 484 445 484 446 484 445 484 419 1255 445 484 445 1254 446 1255 418 1255 446 1255 445 1255 445 1254 419 484 446 1255 445 1255 418 511 419 484 446 484 445 484 445 484 445 485 418 511 418 484 446 1255 445 1255 418 1255 445 1255 445 1255 446 1255 418 1256 445 1255 445 484 419 511 418 485 444 1256 444 485 445 484 445 485 417 485 445 1256 444 485 444 485 445 1256 417 485 445 485 444 486 443 1256 417 1283 417 1256 444 485 420 509 445 485 417 485 445 485 443 486 443 1257 443 487 417 485 420 510 444 485 443 487 419 510 416 513 417 1256 442 487 420 510 419 1281 392 1281 419 510 443 486 420 510 443 487 416 513 417 486 443 486 443 486 444 486 419 510 417 1257 419 511 443 487 418 511 418 511 392 511 419 511 419 511 418 511 443 1258 391 1282 443 487 418 511 418 511 418 512 391 538 418 1256 417 1282 418 1282 391 512 417 512 417 512 417 512 417 513 417 512 391 513 416 536 393 536 393 536 393 537 366 563 367 537 393 536 393 536 393 537 393 537 366 564 366 537 393 537 393 1308 392 537 366 563 366 537 393 537 393 537 392 537 393 537 366 564 366 537 393 537 392 537 393 537 392 537 366 564 365 537 393 537 392 537 392 537 392 537 366 564 366 537 392 537 392 537 393 537 392 537 366 564 365 538 392 538 392 538 391 538 392 538 365 538 392 537 392 538 391 538 391 538 391 538 365 565 364 538 392 538 391 538 392 538 391 538 365 538 391 538 392 538 391 538 391 1309 364 1310 390 539 391 539 390 539 390 539 364 566 363 539 391 539 390 539 390 539 390 1310 363 1310 391 539 390 539 390 540 363 567 362 540 390 539 390 540 390 541 388 564 338 568 362 565 364 565 364 565 365 1335 338 1336 364 565 364 565 364 565 364 566 364 1309 391
+# 
+name: TEMP+
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 531 372 30125 50084 3425 1651 471 1229 471 458 471 458 445 485 445 458 472 458 472 458 471 458 471 458 445 485 444 459 471 458 472 1229 471 458 445 485 444 459 470 459 471 459 471 459 470 459 444 1230 470 1230 470 459 471 459 470 459 444 459 470 459 471 459 470 459 470 460 470 1204 469 459 470 1230 470 1231 442 1231 469 1231 469 1231 469 1231 443 460 469 1231 469 1231 442 487 443 461 468 461 468 461 468 461 469 462 441 489 441 461 468 1255 445 1255 418 1282 418 1282 418 1256 444 1256 418 1256 444 1256 444 485 445 485 418 485 445 1256 444 485 444 485 444 485 418 485 444 1256 444 485 444 485 444 1256 417 485 445 485 444 485 444 485 444 485 418 512 417 1256 444 485 444 485 445 485 418 512 417 485 444 1256 444 486 443 486 416 513 417 486 444 486 443 486 443 486 444 486 417 1257 443 486 444 1257 443 1257 416 486 444 486 443 486 443 487 442 487 416 513 416 487 418 511 443 487 442 487 418 1282 440 462 442 487 442 488 442 487 443 487 416 514 415 487 418 512 442 1258 442 1258 414 489 418 512 417 512 417 512 440 490 440 1260 413 1260 417 1283 441 488 391 539 390 512 441 488 417 512 417 513 416 512 391 539 390 513 438 491 417 513 416 513 416 513 389 540 390 514 415 513 417 513 416 513 416 514 388 541 388 1285 415 538 391 514 415 538 365 541 389 538 391 538 391 538 391 538 391 539 364 565 364 538 392 538 391 538 391 539 390 539 364 539 390 538 391 539 390 539 390 539 391 539 363 539 390 539 390 539 390 539 390 539 390 539 363 540 390 539 390 539 390 539 391 539 364 566 363 540 390 540 390 540 390 539 390 540 362 566 363 540 390 540 389 540 389 540 390 540 362 567 362 540 390 540 389 1311 389 1311 362 566 363 541 389 566 363 566 363 566 363 566 337 566 363 566 363 566 363 1337 336 1363 337 566 363 566 363 566 363 566 363 566 363 540 363 567 362 567 362 567 362 567 336 594 335 567 363 1337 363 1338 362 568 334 594 335 568 362 568 362 568 361 1364 496
+# 
+name: TEMP-
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 479 398 30129 50086 3427 1675 446 1254 446 483 446 483 420 510 420 483 446 483 447 483 446 483 446 483 420 510 419 483 447 483 446 1254 446 484 419 510 420 484 446 483 446 484 446 484 445 484 419 1254 446 1254 446 484 445 484 445 484 419 484 446 484 446 484 445 484 446 484 419 1281 419 484 446 1255 445 1254 419 1254 446 1255 445 1255 445 1255 418 484 446 1255 445 1255 445 484 419 485 445 484 445 484 445 484 445 484 418 511 419 484 445 1255 445 1255 418 1282 418 1255 445 1255 445 1255 418 1282 418 1256 444 485 444 485 418 485 444 1256 443 486 444 485 445 485 418 485 444 1256 444 485 444 485 420 1281 418 485 443 486 444 485 420 1280 444 485 418 485 420 1280 444 486 443 487 417 512 416 487 420 510 444 1256 444 485 417 513 416 487 443 486 420 510 419 510 420 510 417 1257 443 486 419 510 419 1281 417 1257 419 510 420 510 420 509 419 511 418 511 392 511 419 510 443 486 419 511 418 510 393 1308 392 511 419 510 419 510 419 511 418 511 391 511 419 511 418 511 418 1281 419 1281 416 487 418 511 418 511 418 511 419 511 392 1281 419 1282 418 1282 392 537 392 511 418 511 419 511 419 511 419 511 392 538 392 512 418 511 419 511 418 512 418 512 391 538 391 512 418 512 417 512 418 512 417 512 391 539 390 512 417 1283 417 512 417 512 391 539 390 513 416 513 417 513 416 513 416 537 366 540 390 537 393 537 392 537 392 537 392 537 366 564 365 537 393 537 392 537 392 537 392 537 366 564 365 538 392 537 392 537 392 538 391 537 366 538 392 538 391 538 392 538 392 538 391 538 365 538 392 538 392 538 391 538 391 538 391 538 365 538 392 538 391 538 392 538 391 538 364 565 364 538 391 538 392 538 391 1309 364 1336 364 538 392 538 391 538 391 538 391 538 364 539 391 538 391 539 390 539 391 1309 364 1309 391 538 391 539 391 539 390 539 363 566 363 539 391 539 390 539 390 539 390 539 363 566 364 539 391 539 391 539 390 1310 363 566 364 539 391 539 390 540 389 1310 497
+#
+name: POWER
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 454 414 452 413 453 413 453 413 453 412 454 25103 3488 1708 454 1278 454 413 453 413 453 413 453 1278 454 413 453 413 453 412 453 413 453 1278 479 388 478 1254 478 1255 477 389 476 1257 475 1283 449 1283 449 1284 448 1284 448 417 449 417 449 1284 448 417 449 417 449 417 449 417 449 418 448 417 449 418 448 417 449 418 448 418 448 1284 448 418 448 1284 448 418 448 418 448 418 448 1284 448 1284 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 447 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1284 448 1284 448 1285 447 418 448 418 448 1285 447 1285 447 1285 447 35478 3510 1713 449 1284 448 418 448 418 448 417 449 1284 448 418 448 418 448 418 448 418 448 1284 448 418 448 1284 448 1284 448 417 449 1284 448 1284 448 1284 448 1284 448 1284 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 447 418 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 1285 447 418 448 418 447 418 448 418 448 418 448 418 448 418 448 418 448 418 447 418 448 418 448 419 447 419 447 1285 447 418 448 418 448 418 448 418 448 418 448 1285 447 419 447 418 448 1285 447 1285 447 418 448 35479 3509 1713 449 1284 448 417 449 417 449 417 449 1284 448 418 448 418 448 418 448 418 448 1284 448 418 448 1284 448 1284 448 418 448 1284 448 1284 448 1284 448 1284 448 1284 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 447 418 448 418 448 1285 447 418 448 418 448 1285 447 418 448 418 448 418 448 418 448 418 448 418 448 1285 447 418 448 418 448 1285 447 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 419 447 418 448 418 448 1285 447 419 447 1285 447 418 448 418 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 1285 447 1286 446 419 447 419 447 419 447 419 447 419 447 419 447 419 447 420 446 419 446 420 446 1286 446 1286 446 420 446 420 446 419 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 1287 445 420 446 420 446 420 446 420 446 421 445 1287 445 1287 445 421 445 421 445 421 445 421 445 421 445 421 445 421 445 1288 444 421 445 421 445 421 445 422 444 421 445 422 444 421 445 422 444 422 444 1288 444 1288 444 422 444 422 444 422 444 422 444 1289 443
+# 
+name: TEMP+
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 453 414 452 413 453 412 454 414 452 413 453 25102 3490 1707 455 1278 483 384 482 383 482 383 482 1249 483 384 481 384 481 385 480 385 480 1251 481 387 478 1252 480 1253 478 414 451 1281 450 1282 449 1283 448 1283 449 1284 448 417 449 417 449 1284 448 417 449 417 449 417 449 417 449 418 448 417 449 417 449 417 449 417 449 417 449 1284 448 417 449 1284 448 417 449 417 449 417 449 1284 448 1284 448 417 449 417 449 417 449 418 448 1284 448 418 448 417 449 418 448 418 448 417 449 418 448 418 448 418 448 418 448 418 448 418 448 1284 448 1284 448 1284 448 418 448 418 448 1284 448 1284 448 1284 448 35479 3509 1713 449 1284 448 418 448 417 449 418 448 1284 448 417 449 418 448 417 449 418 448 1284 448 418 448 1284 448 1284 448 418 448 1284 448 1284 448 1284 448 1284 448 1284 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 418 447 418 448 1285 447 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 447 418 448 1285 447 418 448 418 448 1285 447 1284 448 418 448 35478 3510 1713 449 1284 448 417 449 417 449 417 449 1284 448 417 449 417 449 417 449 417 449 1284 448 418 448 1284 448 1284 448 417 449 1284 448 1284 448 1284 448 1284 448 1284 448 418 448 417 449 1284 448 418 448 418 448 418 448 418 448 418 448 417 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 447 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 447 418 448 1284 448 1285 447 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 419 447 418 447 419 447 418 448 418 448 418 448 418 448 1285 447 1285 447 419 447 1285 447 419 447 418 448 419 447 419 447 419 447 418 448 419 447 419 447 419 447 419 447 419 447 419 446 419 447 419 447 419 447 419 447 419 447 1285 447 1286 446 419 447 419 447 419 447 419 447 419 447 420 446 419 447 419 447 419 447 419 447 1286 446 1286 446 419 447 1286 446 419 447 420 446 419 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 445 1286 446 420 446 420 446 420 446 420 446 420 446 1287 445 1287 445 420 446 420 446 420 446 421 445 420 446 421 445 421 445 1287 445 421 445 420 446 421 445 421 445 421 445 421 445 421 445 421 445 1287 445 421 445 421 445 1287 445 1287 445 421 445 421 445 1287 445
+# 
+name: TEMP-
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 454 414 451 413 453 413 453 413 453 413 453 25102 3489 1708 454 1277 455 413 452 413 453 413 453 1278 454 412 454 412 454 412 454 412 453 1278 454 413 478 1253 479 1254 477 389 476 1257 475 1283 448 1284 448 1284 448 1284 448 417 449 417 449 1284 448 417 449 417 449 417 449 417 449 418 448 418 448 418 448 418 448 418 448 417 448 1284 448 417 449 1284 448 418 448 418 448 418 448 1284 448 1284 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 419 447 1285 447 1285 447 1285 447 419 447 419 447 1285 447 1285 447 1285 447 35505 3483 1713 449 1284 448 417 449 417 449 418 448 1284 448 417 449 417 449 417 449 418 448 1284 448 418 448 1284 448 1284 448 418 448 1284 448 1284 448 1284 448 1284 448 1284 448 417 449 418 448 1284 448 417 449 418 448 418 448 418 448 418 448 418 448 418 448 418 447 418 448 418 448 418 448 1285 447 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1285 447 418 448 418 448 418 448 418 448 418 448 1285 447 418 447 418 448 1284 448 1285 447 418 448 35481 3508 1713 448 1284 448 417 449 418 448 418 448 1284 448 418 448 418 448 417 449 418 448 1284 448 418 448 1284 448 1284 448 418 448 1284 448 1284 448 1284 448 1284 448 1284 448 418 448 418 448 1285 447 418 448 418 448 418 448 418 448 418 448 418 448 419 447 418 448 418 448 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 446 419 447 419 447 419 447 1286 446 419 447 419 447 419 446 419 447 419 447 419 447 1286 446 419 447 419 447 1286 446 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 446 419 447 419 447 419 447 419 447 419 447 1286 446 1286 446 420 446 1286 446 420 446 420 446 419 446 420 446 420 446 420 446 420 446 420 446 420 446 420 445 420 446 421 445 420 446 421 445 421 445 420 446 421 445 1287 445 1287 445 421 445 421 445 422 444 446 420 446 420 423 443 446 420 446 420 446 420 446 420 1312 420 1312 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 419 446 420 446 420 1313 419 446 420 446 420 447 419 447 419 446 420 1313 419 1313 419 447 419 447 419 446 420 447 419 446 420 447 419 447 419 1313 419 447 419 446 420 447 419 447 419 447 419 447 419 447 419 447 419 1313 419 447 419 1313 419 447 419 1313 419 447 419 447 419 1313 419
+# 
+name: MODE
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 484 410 456 385 481 385 481 384 482 385 481 25074 3521 1676 483 1249 483 410 484 382 485 381 485 1247 485 381 484 381 485 381 484 382 483 1248 484 383 482 1249 482 1250 481 385 480 1253 478 1254 478 1255 477 1256 476 1256 476 389 477 389 477 1256 476 390 476 390 476 390 476 389 477 390 476 390 476 390 476 390 476 390 476 389 476 1256 476 390 476 1256 476 390 476 390 476 390 476 1256 476 1256 476 390 476 390 476 390 476 390 476 1257 475 390 476 390 476 390 476 390 476 390 476 390 476 390 476 390 475 391 475 391 475 390 476 1257 475 1257 475 1257 475 391 475 391 475 1257 475 1258 474 1258 474 35476 3516 1682 476 1256 476 390 476 389 477 389 477 1256 476 389 477 389 477 389 477 389 477 1256 476 389 477 1256 476 1256 476 390 476 1256 476 1256 476 1256 476 1256 476 1256 476 390 476 390 476 1256 476 390 476 390 476 390 476 390 476 390 476 390 476 390 476 390 476 390 476 390 476 390 476 1256 476 390 476 390 476 390 476 390 476 1257 475 390 476 390 476 390 475 391 475 390 476 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 1257 475 391 475 391 475 391 475 391 475 391 475 1258 474 392 474 392 474 1258 474 1259 473 416 450 35476 3516 1682 477 1257 475 390 476 390 476 390 476 1256 476 390 476 390 476 390 476 390 476 1257 475 390 476 1257 475 1257 475 390 476 1257 475 1257 475 1257 475 1257 475 1258 474 391 475 391 475 1258 474 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 391 475 392 474 391 475 391 475 391 475 392 474 392 474 391 475 392 474 1282 450 416 450 1283 449 416 450 416 450 416 450 416 450 393 473 416 449 416 450 416 450 1283 449 1283 449 417 449 417 449 416 449 417 449 416 450 416 450 417 449 416 450 416 450 417 449 416 450 417 449 417 449 1283 449 417 449 1283 449 417 449 417 449 417 449 417 449 417 449 417 449 417 448 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 1284 448 1283 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 1284 448 1284 448 417 449 418 448 417 449 418 448 418 448 418 448 418 448 418 448 418 448 418 448 417 449 418 447 418 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 1284 448 1285 447 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1285 447 418 448 418 448 418 448 418 448 418 448 419 447 418 448 418 448 1285 447 418 447 419 447 419 447 418 448 419 447 1285 447 419 447
+# 
+name: MODE
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 536 335 510 363 509 363 509 335 565 311 505 25378 3540 1697 455 1317 427 418 455 417 455 417 455 1289 456 390 455 417 455 417 455 417 428 1317 454 392 480 1265 480 1265 480 393 479 1268 476 1269 476 1269 476 1269 476 1269 476 397 475 369 476 1269 476 396 476 397 476 396 449 397 476 396 476 397 448 396 476 397 475 397 476 370 475 1270 475 397 475 1270 475 397 475 397 448 397 475 1271 474 1271 474 398 474 398 474 371 474 398 475 398 474 398 447 398 475 398 474 398 447 399 474 400 472 423 449 371 474 399 473 399 473 423 422 1324 421 1324 421 1324 421 423 450 1296 449 423 449 1297 448 1297 448 34986 3534 1704 476 1269 476 396 476 369 476 396 476 1270 475 396 476 369 476 397 476 396 476 1270 475 397 448 1297 448 1297 449 397 476 1270 475 1270 475 1270 475 1270 475 1270 476 397 475 397 475 1270 475 370 475 397 476 397 475 397 448 398 474 397 475 397 476 370 475 398 474 397 475 398 447 1298 447 398 475 398 474 398 447 398 474 1272 473 399 473 398 474 372 473 399 473 399 474 423 422 399 474 423 449 423 449 396 449 423 450 423 449 1296 449 1296 449 423 422 424 449 423 449 423 422 423 449 1297 448 1297 448 424 448 1297 448 1297 448 423 450 34986 3535 1703 476 1269 476 369 476 396 476 396 477 1269 476 396 449 396 477 396 476 396 476 1270 475 369 476 1270 475 1270 475 397 476 1270 475 1270 475 1270 475 1270 475 1270 475 397 476 370 475 1270 475 397 476 397 475 397 448 397 475 397 476 397 475 370 475 398 474 398 475 398 447 398 474 398 474 398 474 371 474 398 474 399 473 371 474 422 451 1272 473 423 449 422 423 1323 422 423 450 1296 449 423 449 423 449 395 450 423 449 423 449 423 422 423 449 423 449 1296 450 1296 449 423 449 396 449 423 449 423 449 423 422 423 449 424 448 424 421 1324 421 1324 421 1324 421 1324 421 424 449 1297 448 424 448 1297 448 1297 448 1297 448 1297 448 1297 448 424 448 397 448 424 448 424 448 424 421 424 449 424 448 424 448 397 448 424 448 424 448 425 420 425 448 1298 447 1298 447 425 447 425 420 425 447 425 447 425 448 397 448 425 447 425 448 425 420 425 448 1298 447 1298 447 425 448 425 447 398 447 425 448 425 447 425 420 425 447 425 448 425 420 425 447 425 447 425 447 398 447 426 446 426 446 426 419 426 446 1299 446 426 446 426 447 398 447 426 446 426 446 1299 446 1299 446 426 419 426 446 426 446 426 447 399 446 427 446 426 446 1300 445 400 445 427 445 427 446 427 418 427 446 427 445 428 444 400 445 453 419 453 419 453 392 453 419 453 420 1326 419 1326 419 453 419
+# SWING_WIDE
+name: SWING
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 484 362 510 363 482 390 454 391 457 416 456 25430 3517 1720 457 1287 458 416 484 387 486 387 458 1286 458 387 485 387 457 414 431 414 458 1286 457 415 459 1286 457 1288 457 415 458 1288 456 1290 455 1290 480 1267 478 1292 453 392 453 420 453 1293 451 421 452 420 425 420 452 420 452 420 452 392 453 420 453 420 452 420 425 420 453 1293 452 421 452 1293 452 421 452 393 452 420 452 1293 452 1294 451 421 452 393 452 420 452 420 452 420 425 420 453 420 452 420 452 393 452 420 452 420 452 420 425 420 452 420 453 420 452 393 452 1293 451 1294 452 1294 451 421 451 1294 451 421 452 1294 451 1294 451 34985 3537 1726 452 1294 451 393 452 420 453 420 452 1293 452 421 424 420 453 420 452 420 452 1293 452 393 453 1293 452 1294 451 421 452 1293 452 1294 451 1294 451 1294 451 1294 451 421 452 421 424 1321 424 421 452 421 452 420 425 421 452 420 452 421 451 393 452 421 452 420 452 421 424 421 452 1294 451 421 452 421 451 394 451 421 451 1294 451 421 452 421 424 421 452 421 451 421 424 421 451 421 451 421 451 394 451 421 451 421 451 421 424 1321 424 1322 423 422 451 421 452 421 451 394 451 421 451 1294 451 1295 450 422 451 1294 451 1295 450 422 423 34985 3536 1726 452 1293 452 420 452 420 453 420 425 1320 425 421 452 420 452 420 452 393 452 1293 451 421 452 1293 451 1294 451 421 452 1293 452 1294 451 1294 451 1294 451 1294 451 421 424 421 452 1293 452 421 452 420 452 393 452 420 452 420 452 420 425 420 452 420 453 420 425 421 452 420 452 420 452 393 452 421 452 420 452 420 425 421 452 420 452 1294 451 421 452 394 451 1294 450 421 452 421 452 421 424 421 451 421 452 421 424 1322 423 421 452 421 451 1294 451 421 452 394 451 421 452 421 451 421 424 421 452 421 451 421 451 394 451 421 451 421 451 421 424 421 452 421 451 1294 451 1295 450 422 423 422 452 1294 450 1295 451 1295 450 1295 450 422 450 422 451 394 451 421 452 421 452 421 424 422 451 421 451 421 451 394 451 421 451 421 452 421 424 1322 423 1323 422 422 451 422 451 421 451 394 451 421 451 422 450 394 451 421 451 422 450 422 423 1322 422 1323 422 423 450 1295 450 423 450 422 450 395 450 422 450 422 450 422 423 422 451 422 450 422 450 395 450 422 451 422 450 395 450 422 450 422 451 1295 449 423 422 422 451 422 450 422 450 395 450 1295 449 1295 450 423 450 422 451 422 423 422 451 422 450 422 450 395 450 1295 449 423 450 422 451 395 450 422 450 422 450 422 423 422 451 422 450 422 451 1295 449 1296 449 396 449 423 450 1296 448 423 450 423 422
+# 
+name: TEMP+
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 511 362 483 363 509 362 483 391 454 391 457 25457 3518 1719 457 1287 458 389 456 415 457 415 457 1287 485 389 456 388 457 415 457 415 457 1286 459 387 458 1286 459 1287 458 415 483 1262 483 1263 482 1264 481 1265 480 1291 454 419 453 420 425 1320 425 420 453 420 452 420 453 392 453 420 452 420 452 393 452 420 453 420 452 420 425 1320 425 420 453 1293 452 420 453 420 452 393 452 1293 452 1293 452 420 453 420 452 420 425 420 453 420 453 420 452 393 452 420 452 420 452 420 425 420 453 420 452 420 425 420 452 420 452 420 452 1293 452 1293 452 1293 452 393 452 1293 452 420 453 1293 452 1293 452 34983 3540 1724 452 1293 452 420 452 420 425 420 452 1293 452 420 453 420 453 392 453 420 452 1293 452 420 452 1293 452 1293 452 393 452 1293 452 1293 452 1293 452 1293 452 1294 451 420 452 421 452 1293 452 421 424 420 452 420 452 420 452 393 452 420 452 420 452 420 425 421 452 420 453 420 452 1293 452 394 451 421 451 421 451 393 452 1294 451 421 451 421 451 421 424 421 451 421 451 421 452 393 452 421 452 421 451 421 424 421 452 421 451 421 451 1294 451 394 451 421 452 421 451 394 451 421 451 1294 451 421 452 421 424 1322 423 1322 423 422 451 34985 3539 1724 452 1293 452 420 452 420 453 393 452 1293 452 421 452 420 452 420 425 420 452 1293 452 421 452 1293 452 1294 451 421 424 1321 424 1322 424 1321 424 1321 424 1321 424 421 451 421 452 1294 451 421 452 393 452 421 451 421 452 420 425 421 452 420 452 421 451 393 452 420 452 421 452 421 424 421 451 421 452 421 451 393 452 421 451 421 451 1294 451 394 452 421 451 1294 451 421 452 421 424 421 452 421 451 421 451 1294 451 1295 451 394 451 422 451 1294 450 422 451 421 424 421 451 421 451 421 452 394 451 422 451 422 450 394 451 421 451 421 451 421 424 422 451 422 450 1295 450 1295 450 422 450 395 450 422 450 422 450 422 423 422 450 422 450 422 451 394 451 422 450 422 450 395 450 422 450 422 450 422 423 422 451 422 450 422 450 395 450 1295 449 1296 449 423 449 423 450 423 422 423 450 422 450 423 449 396 449 423 450 423 449 423 422 1324 420 1324 422 424 449 1297 448 424 449 423 422 423 450 424 448 424 448 396 449 423 449 423 449 424 421 424 449 424 449 423 449 396 449 423 449 424 449 1297 447 425 420 425 448 424 449 424 421 425 448 1297 447 1298 447 425 447 425 448 397 448 425 447 424 448 425 420 426 447 1322 423 450 423 449 423 422 423 450 422 450 423 450 395 450 422 450 422 1323 421 451 395 450 423 1323 421 1324 421 451 421 451 422 423 422
+# 
+name: TEMP-
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 538 335 510 362 510 362 510 338 507 338 534 25377 3593 1642 510 1235 510 363 537 335 509 363 509 1209 537 335 510 361 511 362 510 362 483 1262 483 363 508 1236 508 1237 507 366 478 1268 477 1269 476 1269 476 1270 475 1270 475 397 475 370 475 1270 475 397 475 397 475 397 448 397 476 397 475 397 476 369 476 397 475 397 475 370 475 1270 475 397 475 1270 475 397 475 397 448 397 475 1271 474 1270 475 397 475 397 475 370 475 398 474 398 474 397 448 398 475 398 474 397 475 370 475 398 474 398 475 370 475 398 475 398 474 398 447 1299 447 1299 446 1299 446 398 474 1271 474 399 474 1271 474 1272 473 34986 3534 1703 476 1269 476 396 476 369 476 396 476 1269 476 396 476 397 448 397 476 396 477 1269 476 397 448 1297 448 1297 448 396 476 1270 475 1270 475 1270 475 1270 475 1270 475 397 475 397 475 1270 475 370 475 397 475 397 475 397 448 397 475 397 475 397 475 370 475 397 475 397 475 397 448 1298 447 398 475 398 475 398 447 398 474 1271 474 398 474 398 474 395 450 422 450 422 450 422 423 422 450 422 450 423 450 395 450 422 451 422 450 423 422 1323 422 423 449 423 449 422 450 395 450 423 449 1296 450 422 450 395 450 1296 449 1296 449 423 449 34986 3535 1703 476 1269 476 396 476 396 449 397 475 1270 475 396 477 396 476 369 476 397 476 1269 476 397 475 1270 476 1270 475 397 448 1298 447 1298 447 1297 448 1298 447 1298 448 398 474 398 474 1295 450 398 447 398 474 422 450 422 451 395 450 422 450 422 450 422 423 422 451 422 450 422 450 395 450 422 450 422 451 422 423 422 450 422 451 422 423 1323 423 422 450 422 451 1295 450 422 450 395 450 422 450 422 451 422 423 423 450 1295 450 422 450 422 451 1295 450 395 450 422 450 423 449 422 423 423 449 423 450 422 423 423 449 423 450 422 450 396 449 423 449 423 449 423 422 1324 421 1323 422 423 450 423 449 423 449 396 449 423 449 423 449 423 422 423 450 423 450 423 449 396 449 423 449 423 450 396 449 424 448 424 449 423 422 424 449 424 448 1297 448 1297 448 424 448 397 448 424 449 424 448 424 421 424 448 424 449 424 449 396 449 424 448 1297 448 1297 448 424 448 1297 448 397 448 424 448 424 449 424 421 425 448 424 448 424 448 398 447 424 448 424 448 425 420 425 447 425 447 425 448 397 448 1298 447 425 447 425 447 398 448 425 447 425 447 1298 447 1298 447 425 420 425 447 425 448 425 447 398 447 425 447 426 446 1299 446 426 419 426 447 425 447 426 446 399 446 426 446 426 447 426 419 1326 419 1327 418 1327 419 426 446 1300 445 426 446 426 419 427 446
+# SWING_WIDE
+name: SWING
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 454 413 453 412 454 412 454 412 454 413 453 25102 3490 1707 483 1249 484 383 483 383 482 383 509 1222 483 383 482 384 481 385 480 385 480 1250 482 386 479 1252 479 1254 477 414 451 1281 450 1282 449 1283 449 1283 449 1284 448 417 448 417 449 1284 448 417 449 417 449 418 448 417 449 417 449 417 449 417 449 417 449 417 449 417 449 1284 448 418 448 1284 448 418 448 418 448 418 448 1284 448 1284 448 418 448 418 448 417 448 418 448 1284 448 417 449 417 448 418 448 417 449 417 449 417 449 418 448 417 449 418 448 418 448 418 448 1284 448 1284 448 1284 449 417 449 418 448 1284 448 1284 448 1284 448 35505 3485 1712 449 1283 449 417 449 417 449 417 449 1284 448 417 449 417 449 417 449 417 449 1284 448 417 449 1284 448 1284 448 417 449 1284 448 1284 448 1284 448 1283 449 1284 448 417 449 417 449 1284 448 417 449 417 449 417 449 417 449 417 449 417 449 417 449 417 449 418 448 418 448 417 449 1284 448 417 449 417 449 417 449 417 449 1284 448 417 448 418 448 418 448 417 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 418 448 418 448 418 448 1284 448 418 448 418 448 1285 447 1285 447 418 448 35504 3486 1712 449 1283 449 417 449 417 448 417 449 1284 448 417 449 417 449 417 449 417 448 1284 448 417 449 1284 448 1284 448 417 449 1283 449 1284 448 1284 448 1284 448 1284 449 417 449 417 449 1284 448 417 449 417 449 418 448 417 449 417 449 417 449 418 448 417 449 417 449 418 448 418 448 418 448 417 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1284 448 1284 448 1284 448 418 448 418 448 418 448 1284 448 418 448 418 448 1284 448 1284 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 418 448 1285 447 1285 447 418 448 1285 447 1285 447 1285 447 1285 447 1285 447 419 447 418 448 419 447 418 448 418 448 418 448 419 447 419 447 418 448 418 448 419 447 419 447 419 447 1285 447 1285 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 1286 446 1285 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 419 447 1286 446 420 446 420 446 420 446 420 446 419 447 1286 446 1286 446 419 447 420 446 420 446 420 446 420 446 420 446 420 446 1286 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 420 446 1286 446 420 446 420 446 420 446 1287 445 1287 445 1287 445
diff --git a/assets/resources/infrared/assets/audio.ir b/assets/resources/infrared/assets/audio.ir
index b3b56e211e..4a5fe8f85e 100644
--- a/assets/resources/infrared/assets/audio.ir
+++ b/assets/resources/infrared/assets/audio.ir
@@ -1,7 +1,7 @@
 Filetype: IR library file
 Version: 1
-# Last Updated 21st Feb, 2023
-# Last Checked 21st Feb, 2023
+# Last Updated 07th Mar, 2023
+# Last Checked 07th Mar, 2023
 # 
 name: POWER
 type: parsed
@@ -2092,3 +2092,9 @@ type: parsed
 protocol: NECext
 address: 30 FC 00 00
 command: 17 E8 00 00
+# 
+name: POWER
+type: parsed
+protocol: NEC
+address: 00 00 00 00
+command: 04 00 00 00
diff --git a/assets/resources/infrared/assets/fans.ir b/assets/resources/infrared/assets/fans.ir
index 535f962740..d242bfdd64 100644
--- a/assets/resources/infrared/assets/fans.ir
+++ b/assets/resources/infrared/assets/fans.ir
@@ -1,7 +1,7 @@
 Filetype: IR library file
 Version: 1
 # Last Updated 15th Feb, 2023
-# Last Checked 21st Feb, 2023
+# Last Checked 07th Mar, 2023
 #
 name: POWER
 type: raw
diff --git a/assets/resources/infrared/assets/projectors.ir b/assets/resources/infrared/assets/projectors.ir
index d073dccfa9..2be118e9c0 100644
--- a/assets/resources/infrared/assets/projectors.ir
+++ b/assets/resources/infrared/assets/projectors.ir
@@ -1,7 +1,7 @@
 Filetype: IR library file
 Version: 1
-# Last Updated 21st Feb, 2023
-# Last Checked 21st Feb, 2023
+# Last Updated 07th Mar, 2023
+# Last Checked 07th Mar, 2023
 #
 # ON
 name: POWER
@@ -844,3 +844,33 @@ type: raw
 frequency: 38000
 duty_cycle: 0.330000
 data: 8811 4222 530 1580 531 1579 531 507 531 507 531 507 531 508 531 508 530 1582 528 1583 527 535 503 1608 502 536 501 1609 501 537 501 1610 500 538 500 1611 499 538 500 539 500 538 500 1611 500 539 499 538 500 1611 499 539 499 1611 499 1611 500 1611 499 539 499 1611 500 1611 500 539 499 35437 8784 4252 500 1611 500 1612 500 539 500 539 500 539 500 539 500 539 500 1611 500 1612 499 539 500 1612 500 539 500 1612 499 539 500 1612 500 539 500 1612 499 539 500 539 500 539 499 1612 499 540 499 539 500 1612 499 539 500 1612 499 1613 499 1612 499 539 500 1612 500 1612 500 539 500
+# 
+name: VOL+
+type: parsed
+protocol: NEC
+address: 01 00 00 00
+command: 06 00 00 00
+# 
+name: VOL-
+type: parsed
+protocol: NEC
+address: 01 00 00 00
+command: 09 00 00 00
+# 
+name: MUTE
+type: parsed
+protocol: NEC
+address: 01 00 00 00
+command: 1A 00 00 00
+#
+name: POWER
+type: parsed
+protocol: NEC
+address: 01 00 00 00
+command: 00 00 00 00
+# 
+name: MUTE
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 9035 4437 563 548 563 548 563 522 594 1645 591 1639 592 518 593 548 563 552 563 1640 592 548 563 553 562 1668 564 524 592 1642 594 1674 562 1673 563 1639 593 548 563 552 564 1669 562 548 563 520 615 529 586 1645 587 529 587 1650 586 1646 586 529 586 1650 586 1649 587 1646 586 524 587 524 587 524 587 524 587 525 643 467 644 440 671 467 644 472 643 1592 644 1593 643 1593 642 1594 641 1594 587 1649 585 1651 563 1682 562 14430 9008 2205 562
diff --git a/assets/resources/infrared/assets/tv.ir b/assets/resources/infrared/assets/tv.ir
index 7b203b15e7..fdc62cb022 100755
--- a/assets/resources/infrared/assets/tv.ir
+++ b/assets/resources/infrared/assets/tv.ir
@@ -1,7 +1,7 @@
 Filetype: IR library file
 Version: 1
-# Last Updated 15th Feb, 2023
-# Last Checked 21st Feb, 2023
+# Last Updated 07th Mar, 2023
+# Last Checked 07th Mar, 2023
 #
 name: POWER
 type: parsed
@@ -1863,3 +1863,39 @@ type: parsed
 protocol: RC5
 address: 00 00 00 00
 command: 17 00 00 00
+# 
+name: POWER
+type: parsed
+protocol: NEC
+address: 80 00 00 00
+command: 12 00 00 00
+# 
+name: VOL+
+type: parsed
+protocol: NEC
+address: 80 00 00 00
+command: 1A 00 00 00
+# 
+name: VOL-
+type: parsed
+protocol: NEC
+address: 80 00 00 00
+command: 1E 00 00 00
+# 
+name: MUTE
+type: parsed
+protocol: NEC
+address: 80 00 00 00
+command: 10 00 00 00
+# 
+name: CH+
+type: parsed
+protocol: SIRC20
+address: 10 01 00 00
+command: 34 00 00 00
+# 
+name: CH-
+type: parsed
+protocol: SIRC20
+address: 10 01 00 00
+command: 33 00 00 00
diff --git a/assets/resources/unirf/unirf_map_example.txt b/assets/resources/unirf/unirf_map_example.txt
deleted file mode 100644
index 30f91b8aa0..0000000000
--- a/assets/resources/unirf/unirf_map_example.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-UP: /ext/subghz/Up.sub
-DOWN: /ext/subghz/Down.sub
-LEFT: /ext/subghz/Left.sub
-RIGHT: /ext/subghz/Right.sub
-OK: /ext/subghz/Ok.sub
-ULABEL: Up Label
-DLABEL: Down Label
-LLABEL: Left Label
-RLABEL: Right Label
-OKLABEL: Ok Label
\ No newline at end of file
diff --git a/documentation/SubGHzRemotePlugin.md b/documentation/SubGHzRemotePlugin.md
index 8563dbd5d3..fd48eeca2b 100644
--- a/documentation/SubGHzRemotePlugin.md
+++ b/documentation/SubGHzRemotePlugin.md
@@ -1,6 +1,6 @@
-# UniRF Remix / Sub-GHz Remote
+# Sub-GHz Remote
 
-### The UniRF Tool *requires* the creation of custom user map with `.txt` extension in the `unirf` folder on the sdcard. 
+### The SubGHz Remote Tool *requires* the creation of custom user map with `.txt` extension in the `subghz_remote` folder on the sdcard. 
 
 #### If these files are not exist or not configured properly, **you will receive an error each time you try to select wrong file in the UniRF Tool**.
 
@@ -20,7 +20,7 @@ Press Back to Exit
 
 
 
-## Setting up the `unirf/example.txt` file:
+## Setting up the `subghz_remote/example.txt` file:
 
 ```
 UP: /ext/subghz/Up.sub
@@ -59,7 +59,7 @@ OKLABEL: Garage CLOSE
   - Press a button to send the assigned capture file.
   - Press Back button to exit app.
 
-* ##### Universal RF Map
+* ##### SubGHz Remote Map
   - File path should not have any spaces or special characters (- and _ excluded).
   - Labels are limited to 16 characters.
     - Why? This is to prevent overlapping elements on screen.
diff --git a/documentation/fbt.md b/documentation/fbt.md
index 3930cd5918..65729c5c84 100644
--- a/documentation/fbt.md
+++ b/documentation/fbt.md
@@ -9,8 +9,8 @@ To use `fbt`, you only need `git` installed in your system.
 
 `fbt` by default downloads and unpacks a pre-built toolchain, and then modifies environment variables for itself to use it. It does not contaminate your global system's path with the toolchain.
  > However, if you wish to use tools supplied with the toolchain outside `fbt`, you can open an *fbt shell*, with properly configured environment.
- >    - On Windows, simply run `scripts/toochain/fbtenv.cmd`.
- >    - On Linux & MacOS, run `source scripts/toochain/fbtenv.sh` in a new shell.
+ >    - On Windows, simply run `scripts/toolchain/fbtenv.cmd`.
+ >    - On Linux & MacOS, run `source scripts/toolchain/fbtenv.sh` in a new shell.
  
  If your system is not supported by pre-built toolchain variants or you want to use custom versions of dependencies, you can `set FBT_NOENV=1`. `fbt` will skip toolchain & environment configuration and will expect all tools to be available on your system's `PATH`. *(this option is not available on Windows)*
  
diff --git a/documentation/file_formats/iButtonFileFormat.md b/documentation/file_formats/iButtonFileFormat.md
index c04586195b..adb493e055 100644
--- a/documentation/file_formats/iButtonFileFormat.md
+++ b/documentation/file_formats/iButtonFileFormat.md
@@ -4,26 +4,47 @@
 
 ```
 Filetype: Flipper iButton key
-Version: 1
-# Key type can be Cyfral, Dallas or Metakom
-Key type: Dallas
-# Data size for Cyfral is 2, for Metakom is 4, for Dallas is 8
-Data: 12 34 56 78 9A BC DE F0
+Version: 2
+Protocol: DS1992
+Rom Data: 08 DE AD BE EF FA CE 4E
+Sram Data: 4E 65 76 65 72 47 6F 6E 6E 61 47 69 76 65 59 6F 75 55 70 4E 65 76 65 72 47 6F 6E 6E 61 4C 65 74 59 6F 75 44 6F 77 6E 4E 65 76 65 72 47 6F 6E 6E 61 52 75 6E 41 72 6F 75 6E 64 41 6E 64 44 65 73 65 72 74 59 6F 75 4E 65 76 65 72 47 6F 6E 6E 61 4D 61 6B 65 59 6F 75 43 72 79 4E 65 76 65 72 47 6F 6E 6E 61 53 61 79 47 6F 6F 64 62 79 65 4E 65 76 65 72 47 6F 6E 6E 61 54 65 6C 6C 41 4C 69 65
 ```
 
 ## Description
 
 Filename extension: `.ibtn`
 
-The file stores a single iButton key of the type defined by the `Key type` parameter.
+The file stores a single iButton key, complete with all data required by the protocol.
 
-### Version history
+## Version history
+### 2. Current version.
+Changelog:
+- Added support for different Dallas protocols
+- Fields after `Protocol` are protocol-dependent for flexibiliy
+
+#### Format fields
+
+| Name      | Type   | Description                                  |
+| --------- | ------ | -------------------------------------------- |
+| Protocol  | string | Currently supported: DS1990, DS1992, DS1996, DSGeneric*, Cyfral, Metakom |
+| Rom Data  | hex    | Read-only memory data (Dallas protocols only) |
+| Sram Data | hex    | Static RAM data (DS1992 and DS1996 only)
+| Data      | hex    | Key data (Cyfral & Metakom only)              |
+
+NOTE 1: DSGeneric is a catch-all protocol for all unknown 1-Wire devices. It reads only the ROM and does not perform any checks on the read data. 
+It can also be used if a key with a deliberately invalid family code or checksum is required.
+
+NOTE 2: When adding new protocols, it is not necessarily to increase the format version, define the format in the protocol implementation instead.
+
+### 1. Initial version.
+Deprecated, will be converted to current version upon saving.
+
+#### Format fields
+
+| Name     | Type   | Description                                  |
+| -------- | ------ | -------------------------------------------- |
+| Key type | string | Currently supported: Cyfral, Dallas, Metakom |
+| Data     | hex    | Key data                                     |
 
-1. Initial version.
 
-### Format fields
 
-| Name     | Description                                  |
-| -------- | -------------------------------------------- |
-| Key type | Currently supported: Cyfral, Dallas, Metakom |
-| Data     | Key data (HEX values)                        |
diff --git a/firmware/targets/f18/api_symbols.csv b/firmware/targets/f18/api_symbols.csv
index 549d381296..8060d38a20 100644
--- a/firmware/targets/f18/api_symbols.csv
+++ b/firmware/targets/f18/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,15.0,,
+Version,+,18.0,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -156,6 +156,7 @@ Header,+,lib/toolbox/manchester_decoder.h,,
 Header,+,lib/toolbox/manchester_encoder.h,,
 Header,+,lib/toolbox/md5.h,,
 Header,+,lib/toolbox/path.h,,
+Header,+,lib/toolbox/pretty_format.h,,
 Header,+,lib/toolbox/protocols/protocol_dict.h,,
 Header,+,lib/toolbox/random_name.h,,
 Header,+,lib/toolbox/saved_struct.h,,
@@ -439,7 +440,6 @@ Function,-,_wctomb_r,int,"_reent*, char*, wchar_t, _mbstate_t*"
 Function,-,a64l,long,const char*
 Function,+,abort,void,
 Function,-,abs,int,int
-Function,+,acquire_mutex,void*,"ValueMutex*, uint32_t"
 Function,-,aligned_alloc,void*,"size_t, size_t"
 Function,+,aligned_free,void,void*
 Function,+,aligned_malloc,void*,"size_t, size_t"
@@ -573,7 +573,6 @@ Function,-,ctermid,char*,char*
 Function,-,ctime,char*,const time_t*
 Function,-,ctime_r,char*,"const time_t*, char*"
 Function,-,cuserid,char*,char*
-Function,+,delete_mutex,_Bool,ValueMutex*
 Function,+,dialog_ex_alloc,DialogEx*,
 Function,+,dialog_ex_disable_extended_events,void,DialogEx*
 Function,+,dialog_ex_enable_extended_events,void,DialogEx*
@@ -684,6 +683,7 @@ Function,+,file_browser_worker_set_folder_callback,void,"BrowserWorker*, Browser
 Function,+,file_browser_worker_set_item_callback,void,"BrowserWorker*, BrowserWorkerListItemCallback"
 Function,+,file_browser_worker_set_list_callback,void,"BrowserWorker*, BrowserWorkerListLoadCallback"
 Function,+,file_browser_worker_set_long_load_callback,void,"BrowserWorker*, BrowserWorkerLongLoadCallback"
+Function,+,file_info_is_dir,_Bool,const FileInfo*
 Function,+,file_stream_alloc,Stream*,Storage*
 Function,+,file_stream_close,_Bool,Stream*
 Function,+,file_stream_get_error,FS_Error,Stream*
@@ -707,6 +707,7 @@ Function,-,flipper_application_preload_status_to_string,const char*,FlipperAppli
 Function,+,flipper_application_spawn,FuriThread*,"FlipperApplication*, void*"
 Function,+,flipper_format_buffered_file_alloc,FlipperFormat*,Storage*
 Function,+,flipper_format_buffered_file_close,_Bool,FlipperFormat*
+Function,+,flipper_format_buffered_file_open_always,_Bool,"FlipperFormat*, const char*"
 Function,+,flipper_format_buffered_file_open_existing,_Bool,"FlipperFormat*, const char*"
 Function,+,flipper_format_delete_key,_Bool,"FlipperFormat*, const char*"
 Function,+,flipper_format_file_alloc,FlipperFormat*,Storage*
@@ -1234,6 +1235,7 @@ Function,+,furi_thread_flags_get,uint32_t,
 Function,+,furi_thread_flags_set,uint32_t,"FuriThreadId, uint32_t"
 Function,+,furi_thread_flags_wait,uint32_t,"uint32_t, uint32_t, uint32_t"
 Function,+,furi_thread_free,void,FuriThread*
+Function,+,furi_thread_get_appid,const char*,FuriThreadId
 Function,+,furi_thread_get_current,FuriThread*,
 Function,+,furi_thread_get_current_id,FuriThreadId,
 Function,+,furi_thread_get_current_priority,FuriThreadPriority,
@@ -1248,6 +1250,7 @@ Function,+,furi_thread_is_suspended,_Bool,FuriThreadId
 Function,+,furi_thread_join,_Bool,FuriThread*
 Function,+,furi_thread_mark_as_service,void,FuriThread*
 Function,+,furi_thread_resume,void,FuriThreadId
+Function,+,furi_thread_set_appid,void,"FuriThread*, const char*"
 Function,+,furi_thread_set_callback,void,"FuriThread*, FuriThreadCallback"
 Function,+,furi_thread_set_context,void,"FuriThread*, void*"
 Function,+,furi_thread_set_current_priority,void,FuriThreadPriority
@@ -1312,7 +1315,6 @@ Function,+,icon_get_data,const uint8_t*,const Icon*
 Function,+,icon_get_height,uint8_t,const Icon*
 Function,+,icon_get_width,uint8_t,const Icon*
 Function,-,index,char*,"const char*, int"
-Function,+,init_mutex,_Bool,"ValueMutex*, void*, size_t"
 Function,-,initstate,char*,"unsigned, char*, size_t"
 Function,+,input_get_key_name,const char*,InputKey
 Function,+,input_get_type_name,const char*,InputType
@@ -1491,6 +1493,7 @@ Function,+,power_get_pubsub,FuriPubSub*,Power*
 Function,+,power_is_battery_healthy,_Bool,Power*
 Function,+,power_off,void,Power*
 Function,+,power_reboot,void,PowerBootMode
+Function,+,pretty_format_bytes_hex_canonical,void,"FuriString*, size_t, const char*, const uint8_t*, size_t"
 Function,-,printf,int,"const char*, ..."
 Function,+,property_value_out,void,"PropertyValueContext*, const char*, unsigned int, ..."
 Function,+,protocol_dict_alloc,ProtocolDict*,"const ProtocolBase**, size_t"
@@ -1534,12 +1537,10 @@ Function,+,rand,int,
 Function,-,rand_r,int,unsigned*
 Function,+,random,long,
 Function,-,rawmemchr,void*,"const void*, int"
-Function,-,read_mutex,_Bool,"ValueMutex*, void*, size_t, uint32_t"
 Function,+,realloc,void*,"void*, size_t"
 Function,-,reallocarray,void*,"void*, size_t, size_t"
 Function,-,reallocf,void*,"void*, size_t"
 Function,-,realpath,char*,"const char*, char*"
-Function,+,release_mutex,_Bool,"ValueMutex*, const void*"
 Function,-,remove,int,const char*
 Function,-,rename,int,"const char*, const char*"
 Function,-,renameat,int,"int, const char*, int, const char*"
@@ -1617,14 +1618,18 @@ Function,-,srand48,void,long
 Function,-,srandom,void,unsigned
 Function,+,sscanf,int,"const char*, const char*, ..."
 Function,+,storage_common_copy,FS_Error,"Storage*, const char*, const char*"
+Function,+,storage_common_exists,_Bool,"Storage*, const char*"
 Function,+,storage_common_fs_info,FS_Error,"Storage*, const char*, uint64_t*, uint64_t*"
 Function,+,storage_common_merge,FS_Error,"Storage*, const char*, const char*"
+Function,+,storage_common_migrate,FS_Error,"Storage*, const char*, const char*"
 Function,+,storage_common_mkdir,FS_Error,"Storage*, const char*"
 Function,+,storage_common_remove,FS_Error,"Storage*, const char*"
 Function,+,storage_common_rename,FS_Error,"Storage*, const char*, const char*"
+Function,+,storage_common_resolve_path_and_ensure_app_directory,void,"Storage*, FuriString*"
 Function,+,storage_common_stat,FS_Error,"Storage*, const char*, FileInfo*"
 Function,+,storage_common_timestamp,FS_Error,"Storage*, const char*, uint32_t*"
 Function,+,storage_dir_close,_Bool,File*
+Function,+,storage_dir_exists,_Bool,"Storage*, const char*"
 Function,+,storage_dir_open,_Bool,"File*, const char*"
 Function,+,storage_dir_read,_Bool,"File*, FileInfo*, char*, uint16_t"
 Function,-,storage_dir_rewind,_Bool,File*
@@ -1995,7 +2000,6 @@ Function,+,widget_alloc,Widget*,
 Function,+,widget_free,void,Widget*
 Function,+,widget_get_view,View*,Widget*
 Function,+,widget_reset,void,Widget*
-Function,-,write_mutex,_Bool,"ValueMutex*, void*, size_t, uint32_t"
 Function,-,xPortGetFreeHeapSize,size_t,
 Function,-,xPortGetMinimumEverFreeHeapSize,size_t,
 Function,-,xPortStartScheduler,BaseType_t,
diff --git a/firmware/targets/f7/api_symbols.csv b/firmware/targets/f7/api_symbols.csv
index 8e3d0dd319..5320087294 100644
--- a/firmware/targets/f7/api_symbols.csv
+++ b/firmware/targets/f7/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,15.0,,
+Version,+,18.0,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -165,9 +165,10 @@ Header,+,lib/mlib/m-rbtree.h,,
 Header,+,lib/mlib/m-tuple.h,,
 Header,+,lib/mlib/m-variant.h,,
 Header,+,lib/nfc/nfc_device.h,,
+Header,+,lib/one_wire/ibutton/ibutton_key.h,,
+Header,+,lib/one_wire/ibutton/ibutton_protocols.h,,
 Header,+,lib/one_wire/ibutton/ibutton_worker.h,,
 Header,+,lib/one_wire/maxim_crc.h,,
-Header,+,lib/one_wire/one_wire_device.h,,
 Header,+,lib/one_wire/one_wire_host.h,,
 Header,+,lib/one_wire/one_wire_host_timing.h,,
 Header,+,lib/one_wire/one_wire_slave.h,,
@@ -195,6 +196,7 @@ Header,+,lib/toolbox/manchester_decoder.h,,
 Header,+,lib/toolbox/manchester_encoder.h,,
 Header,+,lib/toolbox/md5.h,,
 Header,+,lib/toolbox/path.h,,
+Header,+,lib/toolbox/pretty_format.h,,
 Header,+,lib/toolbox/protocols/protocol_dict.h,,
 Header,+,lib/toolbox/random_name.h,,
 Header,+,lib/toolbox/saved_struct.h,,
@@ -494,7 +496,6 @@ Function,-,acosh,double,double
 Function,-,acoshf,float,float
 Function,-,acoshl,long double,long double
 Function,-,acosl,long double,long double
-Function,+,acquire_mutex,void*,"ValueMutex*, uint32_t"
 Function,-,aligned_alloc,void*,"size_t, size_t"
 Function,+,aligned_free,void,void*
 Function,+,aligned_malloc,void*,"size_t, size_t"
@@ -721,7 +722,6 @@ Function,-,ctermid,char*,char*
 Function,-,ctime,char*,const time_t*
 Function,-,ctime_r,char*,"const time_t*, char*"
 Function,-,cuserid,char*,char*
-Function,+,delete_mutex,_Bool,ValueMutex*
 Function,+,dialog_ex_alloc,DialogEx*,
 Function,+,dialog_ex_disable_extended_events,void,DialogEx*
 Function,+,dialog_ex_enable_extended_events,void,DialogEx*
@@ -867,6 +867,7 @@ Function,+,file_browser_worker_set_folder_callback,void,"BrowserWorker*, Browser
 Function,+,file_browser_worker_set_item_callback,void,"BrowserWorker*, BrowserWorkerListItemCallback"
 Function,+,file_browser_worker_set_list_callback,void,"BrowserWorker*, BrowserWorkerListLoadCallback"
 Function,+,file_browser_worker_set_long_load_callback,void,"BrowserWorker*, BrowserWorkerLongLoadCallback"
+Function,+,file_info_is_dir,_Bool,const FileInfo*
 Function,+,file_stream_alloc,Stream*,Storage*
 Function,+,file_stream_close,_Bool,Stream*
 Function,+,file_stream_get_error,FS_Error,Stream*
@@ -893,6 +894,7 @@ Function,-,flipper_application_preload_status_to_string,const char*,FlipperAppli
 Function,+,flipper_application_spawn,FuriThread*,"FlipperApplication*, void*"
 Function,+,flipper_format_buffered_file_alloc,FlipperFormat*,Storage*
 Function,+,flipper_format_buffered_file_close,_Bool,FlipperFormat*
+Function,+,flipper_format_buffered_file_open_always,_Bool,"FlipperFormat*, const char*"
 Function,+,flipper_format_buffered_file_open_existing,_Bool,"FlipperFormat*, const char*"
 Function,+,flipper_format_delete_key,_Bool,"FlipperFormat*, const char*"
 Function,+,flipper_format_file_alloc,FlipperFormat*,Storage*
@@ -1193,13 +1195,13 @@ Function,+,furi_hal_mpu_protect_disable,void,FuriHalMpuRegion
 Function,+,furi_hal_mpu_protect_no_access,void,"FuriHalMpuRegion, uint32_t, FuriHalMPURegionSize"
 Function,+,furi_hal_mpu_protect_read_only,void,"FuriHalMpuRegion, uint32_t, FuriHalMPURegionSize"
 Function,+,furi_hal_nfc_activate_nfca,_Bool,"uint32_t, uint32_t*"
-Function,-,furi_hal_nfc_deinit,void,
+Function,+,furi_hal_nfc_deinit,void,
 Function,+,furi_hal_nfc_detect,_Bool,"FuriHalNfcDevData*, uint32_t"
 Function,+,furi_hal_nfc_emulate_nfca,_Bool,"uint8_t*, uint8_t, uint8_t*, uint8_t, FuriHalNfcEmulateCallback, void*, uint32_t"
 Function,+,furi_hal_nfc_exit_sleep,void,
 Function,+,furi_hal_nfc_field_off,void,
 Function,+,furi_hal_nfc_field_on,void,
-Function,-,furi_hal_nfc_init,void,
+Function,+,furi_hal_nfc_init,void,
 Function,+,furi_hal_nfc_is_busy,_Bool,
 Function,+,furi_hal_nfc_is_init,_Bool,
 Function,+,furi_hal_nfc_listen,_Bool,"uint8_t*, uint8_t, uint8_t*, uint8_t, _Bool, uint32_t"
@@ -1352,9 +1354,10 @@ Function,+,furi_hal_spi_release,void,FuriHalSpiBusHandle*
 Function,+,furi_hal_subghz_check_radio,_Bool,
 Function,+,furi_hal_subghz_disable_ext_power,void,
 Function,-,furi_hal_subghz_dump_state,void,
-Function,+,furi_hal_subghz_enable_ext_power,void,
+Function,+,furi_hal_subghz_enable_ext_power,_Bool,
 Function,+,furi_hal_subghz_flush_rx,void,
 Function,+,furi_hal_subghz_flush_tx,void,
+Function,+,furi_hal_subghz_get_external_power_disable,_Bool,
 Function,+,furi_hal_subghz_get_lqi,uint8_t,
 Function,+,furi_hal_subghz_get_radio_type,SubGhzRadioType,
 Function,+,furi_hal_subghz_get_rolling_counter_mult,uint8_t,
@@ -1375,6 +1378,7 @@ Function,+,furi_hal_subghz_reset,void,
 Function,+,furi_hal_subghz_rx,void,
 Function,+,furi_hal_subghz_rx_pipe_not_empty,_Bool,
 Function,+,furi_hal_subghz_set_async_mirror_pin,void,const GpioPin*
+Function,+,furi_hal_subghz_set_external_power_disable,void,_Bool
 Function,+,furi_hal_subghz_set_frequency,uint32_t,uint32_t
 Function,+,furi_hal_subghz_set_frequency_and_path,uint32_t,uint32_t
 Function,+,furi_hal_subghz_set_path,void,FuriHalSubGhzPath
@@ -1553,6 +1557,7 @@ Function,+,furi_thread_flags_get,uint32_t,
 Function,+,furi_thread_flags_set,uint32_t,"FuriThreadId, uint32_t"
 Function,+,furi_thread_flags_wait,uint32_t,"uint32_t, uint32_t, uint32_t"
 Function,+,furi_thread_free,void,FuriThread*
+Function,+,furi_thread_get_appid,const char*,FuriThreadId
 Function,+,furi_thread_get_current,FuriThread*,
 Function,+,furi_thread_get_current_id,FuriThreadId,
 Function,+,furi_thread_get_current_priority,FuriThreadPriority,
@@ -1567,6 +1572,7 @@ Function,+,furi_thread_is_suspended,_Bool,FuriThreadId
 Function,+,furi_thread_join,_Bool,FuriThread*
 Function,+,furi_thread_mark_as_service,void,FuriThread*
 Function,+,furi_thread_resume,void,FuriThreadId
+Function,+,furi_thread_set_appid,void,"FuriThread*, const char*"
 Function,+,furi_thread_set_callback,void,"FuriThread*, FuriThreadCallback"
 Function,+,furi_thread_set_context,void,"FuriThread*, void*"
 Function,+,furi_thread_set_current_priority,void,FuriThreadPriority
@@ -1626,22 +1632,33 @@ Function,+,hmac_sha256_update,void,"const hmac_sha256_context*, const uint8_t*,
 Function,-,hypot,double,"double, double"
 Function,-,hypotf,float,"float, float"
 Function,-,hypotl,long double,"long double, long double"
-Function,+,ibutton_key_alloc,iButtonKey*,
-Function,+,ibutton_key_clear_data,void,iButtonKey*
-Function,+,ibutton_key_dallas_crc_is_valid,_Bool,iButtonKey*
-Function,+,ibutton_key_dallas_is_1990_key,_Bool,iButtonKey*
+Function,+,ibutton_key_alloc,iButtonKey*,size_t
 Function,+,ibutton_key_free,void,iButtonKey*
-Function,+,ibutton_key_get_data_p,const uint8_t*,iButtonKey*
-Function,+,ibutton_key_get_data_size,uint8_t,iButtonKey*
-Function,+,ibutton_key_get_max_size,uint8_t,
-Function,+,ibutton_key_get_size_by_type,uint8_t,iButtonKeyType
-Function,+,ibutton_key_get_string_by_type,const char*,iButtonKeyType
-Function,+,ibutton_key_get_type,iButtonKeyType,iButtonKey*
-Function,+,ibutton_key_get_type_by_string,_Bool,"const char*, iButtonKeyType*"
-Function,+,ibutton_key_set,void,"iButtonKey*, const iButtonKey*"
-Function,+,ibutton_key_set_data,void,"iButtonKey*, uint8_t*, uint8_t"
-Function,+,ibutton_key_set_type,void,"iButtonKey*, iButtonKeyType"
-Function,+,ibutton_worker_alloc,iButtonWorker*,
+Function,+,ibutton_key_get_protocol_id,iButtonProtocolId,const iButtonKey*
+Function,+,ibutton_key_reset,void,iButtonKey*
+Function,+,ibutton_key_set_protocol_id,void,"iButtonKey*, iButtonProtocolId"
+Function,+,ibutton_protocols_alloc,iButtonProtocols*,
+Function,+,ibutton_protocols_apply_edits,void,"iButtonProtocols*, const iButtonKey*"
+Function,+,ibutton_protocols_emulate_start,void,"iButtonProtocols*, iButtonKey*"
+Function,+,ibutton_protocols_emulate_stop,void,"iButtonProtocols*, iButtonKey*"
+Function,+,ibutton_protocols_free,void,iButtonProtocols*
+Function,+,ibutton_protocols_get_editable_data,void,"iButtonProtocols*, const iButtonKey*, iButtonEditableData*"
+Function,+,ibutton_protocols_get_features,uint32_t,"iButtonProtocols*, iButtonProtocolId"
+Function,+,ibutton_protocols_get_id_by_name,iButtonProtocolId,"iButtonProtocols*, const char*"
+Function,+,ibutton_protocols_get_manufacturer,const char*,"iButtonProtocols*, iButtonProtocolId"
+Function,+,ibutton_protocols_get_max_data_size,size_t,iButtonProtocols*
+Function,+,ibutton_protocols_get_name,const char*,"iButtonProtocols*, iButtonProtocolId"
+Function,+,ibutton_protocols_get_protocol_count,uint32_t,
+Function,+,ibutton_protocols_is_valid,_Bool,"iButtonProtocols*, const iButtonKey*"
+Function,+,ibutton_protocols_load,_Bool,"iButtonProtocols*, iButtonKey*, const char*"
+Function,+,ibutton_protocols_read,_Bool,"iButtonProtocols*, iButtonKey*"
+Function,+,ibutton_protocols_render_brief_data,void,"iButtonProtocols*, const iButtonKey*, FuriString*"
+Function,+,ibutton_protocols_render_data,void,"iButtonProtocols*, const iButtonKey*, FuriString*"
+Function,+,ibutton_protocols_render_error,void,"iButtonProtocols*, const iButtonKey*, FuriString*"
+Function,+,ibutton_protocols_save,_Bool,"iButtonProtocols*, const iButtonKey*, const char*"
+Function,+,ibutton_protocols_write_blank,_Bool,"iButtonProtocols*, iButtonKey*"
+Function,+,ibutton_protocols_write_copy,_Bool,"iButtonProtocols*, iButtonKey*"
+Function,+,ibutton_worker_alloc,iButtonWorker*,iButtonProtocols*
 Function,+,ibutton_worker_emulate_set_callback,void,"iButtonWorker*, iButtonWorkerEmulateCallback, void*"
 Function,+,ibutton_worker_emulate_start,void,"iButtonWorker*, iButtonKey*"
 Function,+,ibutton_worker_free,void,iButtonWorker*
@@ -1650,8 +1667,9 @@ Function,+,ibutton_worker_read_start,void,"iButtonWorker*, iButtonKey*"
 Function,+,ibutton_worker_start_thread,void,iButtonWorker*
 Function,+,ibutton_worker_stop,void,iButtonWorker*
 Function,+,ibutton_worker_stop_thread,void,iButtonWorker*
+Function,+,ibutton_worker_write_blank_start,void,"iButtonWorker*, iButtonKey*"
+Function,+,ibutton_worker_write_copy_start,void,"iButtonWorker*, iButtonKey*"
 Function,+,ibutton_worker_write_set_callback,void,"iButtonWorker*, iButtonWorkerWriteCallback, void*"
-Function,+,ibutton_worker_write_start,void,"iButtonWorker*, iButtonKey*"
 Function,+,icon_animation_alloc,IconAnimation*,const Icon*
 Function,+,icon_animation_free,void,IconAnimation*
 Function,+,icon_animation_get_height,uint8_t,const IconAnimation*
@@ -1706,7 +1724,6 @@ Function,+,infrared_worker_tx_set_get_signal_callback,void,"InfraredWorker*, Inf
 Function,+,infrared_worker_tx_set_signal_sent_callback,void,"InfraredWorker*, InfraredWorkerMessageSentCallback, void*"
 Function,+,infrared_worker_tx_start,void,InfraredWorker*
 Function,+,infrared_worker_tx_stop,void,InfraredWorker*
-Function,+,init_mutex,_Bool,"ValueMutex*, void*, size_t"
 Function,-,initstate,char*,"unsigned, char*, size_t"
 Function,+,input_get_key_name,const char*,InputKey
 Function,+,input_get_type_name,const char*,InputType
@@ -1915,7 +1932,7 @@ Function,+,menu_free,void,Menu*
 Function,+,menu_get_view,View*,Menu*
 Function,+,menu_reset,void,Menu*
 Function,+,menu_set_selected_item,void,"Menu*, uint32_t"
-Function,-,mf_classic_auth_attempt,_Bool,"FuriHalNfcTxRxContext*, MfClassicAuthContext*, uint64_t"
+Function,-,mf_classic_auth_attempt,_Bool,"FuriHalNfcTxRxContext*, Crypto1*, MfClassicAuthContext*, uint64_t"
 Function,-,mf_classic_auth_init_context,void,"MfClassicAuthContext*, uint8_t"
 Function,-,mf_classic_auth_write_block,_Bool,"FuriHalNfcTxRxContext*, MfClassicBlock*, uint8_t, MfClassicKey, uint64_t"
 Function,-,mf_classic_authenticate,_Bool,"FuriHalNfcTxRxContext*, uint8_t, uint64_t, MfClassicKey"
@@ -2073,12 +2090,6 @@ Function,+,notification_message,void,"NotificationApp*, const NotificationSequen
 Function,+,notification_message_block,void,"NotificationApp*, const NotificationSequence*"
 Function,-,nrand48,long,unsigned short[3]
 Function,-,on_exit,int,"void (*)(int, void*), void*"
-Function,+,onewire_device_alloc,OneWireDevice*,"uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t"
-Function,+,onewire_device_attach,void,"OneWireDevice*, OneWireSlave*"
-Function,+,onewire_device_detach,void,OneWireDevice*
-Function,+,onewire_device_free,void,OneWireDevice*
-Function,+,onewire_device_get_id_p,uint8_t*,OneWireDevice*
-Function,+,onewire_device_send_id,void,OneWireDevice*
 Function,+,onewire_host_alloc,OneWireHost*,const GpioPin*
 Function,+,onewire_host_free,void,OneWireHost*
 Function,+,onewire_host_read,uint8_t,OneWireHost*
@@ -2093,10 +2104,15 @@ Function,+,onewire_host_stop,void,OneWireHost*
 Function,+,onewire_host_target_search,void,"OneWireHost*, uint8_t"
 Function,+,onewire_host_write,void,"OneWireHost*, uint8_t"
 Function,+,onewire_host_write_bit,void,"OneWireHost*, _Bool"
+Function,+,onewire_host_write_bytes,void,"OneWireHost*, const uint8_t*, uint16_t"
 Function,+,onewire_slave_alloc,OneWireSlave*,const GpioPin*
-Function,+,onewire_slave_attach,void,"OneWireSlave*, OneWireDevice*"
-Function,+,onewire_slave_detach,void,OneWireSlave*
 Function,+,onewire_slave_free,void,OneWireSlave*
+Function,+,onewire_slave_receive,_Bool,"OneWireSlave*, uint8_t*, size_t"
+Function,+,onewire_slave_receive_bit,_Bool,OneWireSlave*
+Function,+,onewire_slave_send,_Bool,"OneWireSlave*, const uint8_t*, size_t"
+Function,+,onewire_slave_send_bit,_Bool,"OneWireSlave*, _Bool"
+Function,+,onewire_slave_set_command_callback,void,"OneWireSlave*, OneWireSlaveCommandCallback, void*"
+Function,+,onewire_slave_set_reset_callback,void,"OneWireSlave*, OneWireSlaveResetCallback, void*"
 Function,+,onewire_slave_set_result_callback,void,"OneWireSlave*, OneWireSlaveResultCallback, void*"
 Function,+,onewire_slave_start,void,OneWireSlave*
 Function,+,onewire_slave_stop,void,OneWireSlave*
@@ -2144,6 +2160,7 @@ Function,+,power_off,void,Power*
 Function,+,power_reboot,void,PowerBootMode
 Function,+,powf,float,"float, float"
 Function,-,powl,long double,"long double, long double"
+Function,+,pretty_format_bytes_hex_canonical,void,"FuriString*, size_t, const char*, const uint8_t*, size_t"
 Function,-,printf,int,"const char*, ..."
 Function,-,prng_successor,uint32_t,"uint32_t, uint32_t"
 Function,+,property_value_out,void,"PropertyValueContext*, const char*, unsigned int, ..."
@@ -2188,12 +2205,10 @@ Function,+,rand,int,
 Function,-,rand_r,int,unsigned*
 Function,+,random,long,
 Function,-,rawmemchr,void*,"const void*, int"
-Function,-,read_mutex,_Bool,"ValueMutex*, void*, size_t, uint32_t"
 Function,+,realloc,void*,"void*, size_t"
 Function,-,reallocarray,void*,"void*, size_t, size_t"
 Function,-,reallocf,void*,"void*, size_t"
 Function,-,realpath,char*,"const char*, char*"
-Function,+,release_mutex,_Bool,"ValueMutex*, const void*"
 Function,-,remainder,double,"double, double"
 Function,-,remainderf,float,"float, float"
 Function,-,remainderl,long double,"long double, long double"
@@ -2478,14 +2493,18 @@ Function,+,sscanf,int,"const char*, const char*, ..."
 Function,-,star_line_reset_kl_type,void,
 Function,-,star_line_reset_mfname,void,
 Function,+,storage_common_copy,FS_Error,"Storage*, const char*, const char*"
+Function,+,storage_common_exists,_Bool,"Storage*, const char*"
 Function,+,storage_common_fs_info,FS_Error,"Storage*, const char*, uint64_t*, uint64_t*"
 Function,+,storage_common_merge,FS_Error,"Storage*, const char*, const char*"
+Function,+,storage_common_migrate,FS_Error,"Storage*, const char*, const char*"
 Function,+,storage_common_mkdir,FS_Error,"Storage*, const char*"
 Function,+,storage_common_remove,FS_Error,"Storage*, const char*"
 Function,+,storage_common_rename,FS_Error,"Storage*, const char*, const char*"
+Function,+,storage_common_resolve_path_and_ensure_app_directory,void,"Storage*, FuriString*"
 Function,+,storage_common_stat,FS_Error,"Storage*, const char*, FileInfo*"
 Function,+,storage_common_timestamp,FS_Error,"Storage*, const char*, uint32_t*"
 Function,+,storage_dir_close,_Bool,File*
+Function,+,storage_dir_exists,_Bool,"Storage*, const char*"
 Function,+,storage_dir_open,_Bool,"File*, const char*"
 Function,+,storage_dir_read,_Bool,"File*, FileInfo*, char*, uint16_t"
 Function,-,storage_dir_rewind,_Bool,File*
@@ -2614,9 +2633,10 @@ Function,-,strupr,char*,char*
 Function,-,strverscmp,int,"const char*, const char*"
 Function,-,strxfrm,size_t,"char*, const char*, size_t"
 Function,-,strxfrm_l,size_t,"char*, const char*, size_t, locale_t"
-Function,+,subghz_block_generic_deserialize,_Bool,"SubGhzBlockGeneric*, FlipperFormat*"
+Function,+,subghz_block_generic_deserialize,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*"
+Function,+,subghz_block_generic_deserialize_check_count_bit,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*, uint16_t"
 Function,+,subghz_block_generic_get_preset_name,void,"const char*, FuriString*"
-Function,+,subghz_block_generic_serialize,_Bool,"SubGhzBlockGeneric*, FlipperFormat*, SubGhzRadioPreset*"
+Function,+,subghz_block_generic_serialize,SubGhzProtocolStatus,"SubGhzBlockGeneric*, FlipperFormat*, SubGhzRadioPreset*"
 Function,+,subghz_environment_alloc,SubGhzEnvironment*,
 Function,+,subghz_environment_free,void,SubGhzEnvironment*
 Function,+,subghz_environment_get_alutech_at_4n_rainbow_table_file_name,const char*,SubGhzEnvironment*
@@ -2660,537 +2680,537 @@ Function,+,subghz_protocol_blocks_reverse_key,uint64_t,"uint64_t, uint8_t"
 Function,+,subghz_protocol_blocks_set_bit_array,void,"_Bool, uint8_t[], size_t, size_t"
 Function,+,subghz_protocol_blocks_xor_bytes,uint8_t,"const uint8_t[], size_t"
 Function,-,subghz_protocol_decoder_alutech_at_4n_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_alutech_at_4n_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_alutech_at_4n_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_alutech_at_4n_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_alutech_at_4n_free,void,void*
 Function,-,subghz_protocol_decoder_alutech_at_4n_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_alutech_at_4n_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_alutech_at_4n_reset,void,void*
-Function,-,subghz_protocol_decoder_alutech_at_4n_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_alutech_at_4n_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_ansonic_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_ansonic_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_ansonic_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_ansonic_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_ansonic_free,void,void*
 Function,-,subghz_protocol_decoder_ansonic_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_ansonic_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_ansonic_reset,void,void*
-Function,-,subghz_protocol_decoder_ansonic_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
-Function,-,subghz_protocol_decoder_base_deserialize,_Bool,"SubGhzProtocolDecoderBase*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_ansonic_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,+,subghz_protocol_decoder_base_deserialize,SubGhzProtocolStatus,"SubGhzProtocolDecoderBase*, FlipperFormat*"
 Function,+,subghz_protocol_decoder_base_get_hash_data,uint8_t,SubGhzProtocolDecoderBase*
 Function,+,subghz_protocol_decoder_base_get_string,_Bool,"SubGhzProtocolDecoderBase*, FuriString*"
-Function,+,subghz_protocol_decoder_base_serialize,_Bool,"SubGhzProtocolDecoderBase*, FlipperFormat*, SubGhzRadioPreset*"
+Function,+,subghz_protocol_decoder_base_serialize,SubGhzProtocolStatus,"SubGhzProtocolDecoderBase*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_base_set_decoder_callback,void,"SubGhzProtocolDecoderBase*, SubGhzProtocolDecoderBaseRxCallback, void*"
 Function,-,subghz_protocol_decoder_bett_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_bett_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_bett_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_bett_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_bett_free,void,void*
 Function,-,subghz_protocol_decoder_bett_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_bett_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_bett_reset,void,void*
-Function,-,subghz_protocol_decoder_bett_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_bett_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_bin_raw_alloc,void*,SubGhzEnvironment*
 Function,-,subghz_protocol_decoder_bin_raw_data_input_rssi,void,"SubGhzProtocolDecoderBinRAW*, float"
-Function,-,subghz_protocol_decoder_bin_raw_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_bin_raw_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_bin_raw_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_bin_raw_free,void,void*
 Function,-,subghz_protocol_decoder_bin_raw_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_bin_raw_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_bin_raw_reset,void,void*
-Function,-,subghz_protocol_decoder_bin_raw_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_bin_raw_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_came_alloc,void*,SubGhzEnvironment*
 Function,-,subghz_protocol_decoder_came_atomo_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_came_atomo_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_came_atomo_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_came_atomo_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_came_atomo_free,void,void*
 Function,-,subghz_protocol_decoder_came_atomo_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_came_atomo_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_came_atomo_reset,void,void*
-Function,-,subghz_protocol_decoder_came_atomo_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
-Function,-,subghz_protocol_decoder_came_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_came_atomo_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_came_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_came_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_came_free,void,void*
 Function,-,subghz_protocol_decoder_came_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_came_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_came_reset,void,void*
-Function,-,subghz_protocol_decoder_came_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_came_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_came_twee_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_came_twee_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_came_twee_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_came_twee_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_came_twee_free,void,void*
 Function,-,subghz_protocol_decoder_came_twee_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_came_twee_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_came_twee_reset,void,void*
-Function,-,subghz_protocol_decoder_came_twee_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_came_twee_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_chamb_code_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_chamb_code_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_chamb_code_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_chamb_code_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_chamb_code_free,void,void*
 Function,-,subghz_protocol_decoder_chamb_code_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_chamb_code_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_chamb_code_reset,void,void*
-Function,-,subghz_protocol_decoder_chamb_code_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_chamb_code_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_clemsa_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_clemsa_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_clemsa_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_clemsa_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_clemsa_free,void,void*
 Function,-,subghz_protocol_decoder_clemsa_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_clemsa_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_clemsa_reset,void,void*
-Function,-,subghz_protocol_decoder_clemsa_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_clemsa_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_doitrand_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_doitrand_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_doitrand_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_doitrand_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_doitrand_free,void,void*
 Function,-,subghz_protocol_decoder_doitrand_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_doitrand_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_doitrand_reset,void,void*
-Function,-,subghz_protocol_decoder_doitrand_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_doitrand_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_dooya_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_dooya_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_dooya_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_dooya_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_dooya_free,void,void*
 Function,-,subghz_protocol_decoder_dooya_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_dooya_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_dooya_reset,void,void*
-Function,-,subghz_protocol_decoder_dooya_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_dooya_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_faac_slh_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_faac_slh_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_faac_slh_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_faac_slh_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_faac_slh_free,void,void*
 Function,-,subghz_protocol_decoder_faac_slh_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_faac_slh_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_faac_slh_reset,void,void*
-Function,-,subghz_protocol_decoder_faac_slh_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_faac_slh_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_gate_tx_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_gate_tx_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_gate_tx_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_gate_tx_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_gate_tx_free,void,void*
 Function,-,subghz_protocol_decoder_gate_tx_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_gate_tx_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_gate_tx_reset,void,void*
-Function,-,subghz_protocol_decoder_gate_tx_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_gate_tx_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_holtek_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_holtek_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_holtek_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_holtek_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_holtek_free,void,void*
 Function,-,subghz_protocol_decoder_holtek_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_holtek_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_holtek_reset,void,void*
-Function,-,subghz_protocol_decoder_holtek_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_holtek_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_holtek_th12x_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_holtek_th12x_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_holtek_th12x_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_holtek_th12x_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_holtek_th12x_free,void,void*
 Function,-,subghz_protocol_decoder_holtek_th12x_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_holtek_th12x_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_holtek_th12x_reset,void,void*
-Function,-,subghz_protocol_decoder_holtek_th12x_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_holtek_th12x_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_honeywell_wdb_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_honeywell_wdb_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_honeywell_wdb_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_honeywell_wdb_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_honeywell_wdb_free,void,void*
 Function,-,subghz_protocol_decoder_honeywell_wdb_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_honeywell_wdb_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_honeywell_wdb_reset,void,void*
-Function,-,subghz_protocol_decoder_honeywell_wdb_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_honeywell_wdb_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_hormann_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_hormann_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_hormann_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_hormann_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_hormann_free,void,void*
 Function,-,subghz_protocol_decoder_hormann_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_hormann_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_hormann_reset,void,void*
-Function,-,subghz_protocol_decoder_hormann_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_hormann_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_ido_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_ido_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_ido_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_ido_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_ido_free,void,void*
 Function,-,subghz_protocol_decoder_ido_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_ido_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_ido_reset,void,void*
-Function,-,subghz_protocol_decoder_ido_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_ido_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_intertechno_v3_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_intertechno_v3_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_intertechno_v3_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_intertechno_v3_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_intertechno_v3_free,void,void*
 Function,-,subghz_protocol_decoder_intertechno_v3_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_intertechno_v3_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_intertechno_v3_reset,void,void*
-Function,-,subghz_protocol_decoder_intertechno_v3_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_intertechno_v3_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_keeloq_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_keeloq_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_keeloq_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_keeloq_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_keeloq_free,void,void*
 Function,-,subghz_protocol_decoder_keeloq_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_keeloq_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_keeloq_reset,void,void*
-Function,-,subghz_protocol_decoder_keeloq_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_keeloq_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_kia_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_kia_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_kia_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_kia_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_kia_free,void,void*
 Function,-,subghz_protocol_decoder_kia_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_kia_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_kia_reset,void,void*
-Function,-,subghz_protocol_decoder_kia_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_kia_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_kinggates_stylo_4k_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_kinggates_stylo_4k_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_kinggates_stylo_4k_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_kinggates_stylo_4k_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_kinggates_stylo_4k_free,void,void*
 Function,-,subghz_protocol_decoder_kinggates_stylo_4k_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_kinggates_stylo_4k_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_kinggates_stylo_4k_reset,void,void*
-Function,-,subghz_protocol_decoder_kinggates_stylo_4k_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_kinggates_stylo_4k_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_linear_alloc,void*,SubGhzEnvironment*
 Function,-,subghz_protocol_decoder_linear_delta3_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_linear_delta3_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_linear_delta3_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_linear_delta3_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_linear_delta3_free,void,void*
 Function,-,subghz_protocol_decoder_linear_delta3_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_linear_delta3_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_linear_delta3_reset,void,void*
-Function,-,subghz_protocol_decoder_linear_delta3_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
-Function,-,subghz_protocol_decoder_linear_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_linear_delta3_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_linear_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_linear_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_linear_free,void,void*
 Function,-,subghz_protocol_decoder_linear_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_linear_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_linear_reset,void,void*
-Function,-,subghz_protocol_decoder_linear_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_linear_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_magellan_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_magellan_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_magellan_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_magellan_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_magellan_free,void,void*
 Function,-,subghz_protocol_decoder_magellan_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_magellan_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_magellan_reset,void,void*
-Function,-,subghz_protocol_decoder_magellan_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_magellan_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_marantec_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_marantec_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_marantec_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_marantec_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_marantec_free,void,void*
 Function,-,subghz_protocol_decoder_marantec_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_marantec_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_marantec_reset,void,void*
-Function,-,subghz_protocol_decoder_marantec_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_marantec_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_megacode_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_megacode_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_megacode_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_megacode_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_megacode_free,void,void*
 Function,-,subghz_protocol_decoder_megacode_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_megacode_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_megacode_reset,void,void*
-Function,-,subghz_protocol_decoder_megacode_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_megacode_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_nero_radio_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_nero_radio_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_nero_radio_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_nero_radio_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_nero_radio_free,void,void*
 Function,-,subghz_protocol_decoder_nero_radio_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_nero_radio_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_nero_radio_reset,void,void*
-Function,-,subghz_protocol_decoder_nero_radio_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_nero_radio_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_nero_sketch_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_nero_sketch_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_nero_sketch_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_nero_sketch_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_nero_sketch_free,void,void*
 Function,-,subghz_protocol_decoder_nero_sketch_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_nero_sketch_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_nero_sketch_reset,void,void*
-Function,-,subghz_protocol_decoder_nero_sketch_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_nero_sketch_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_nice_flo_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_nice_flo_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_nice_flo_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_nice_flo_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_nice_flo_free,void,void*
 Function,-,subghz_protocol_decoder_nice_flo_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_nice_flo_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_nice_flo_reset,void,void*
-Function,-,subghz_protocol_decoder_nice_flo_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_nice_flo_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_nice_flor_s_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_nice_flor_s_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_nice_flor_s_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_nice_flor_s_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_nice_flor_s_free,void,void*
 Function,-,subghz_protocol_decoder_nice_flor_s_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_nice_flor_s_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_nice_flor_s_reset,void,void*
-Function,-,subghz_protocol_decoder_nice_flor_s_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_nice_flor_s_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_phoenix_v2_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_phoenix_v2_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_phoenix_v2_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_phoenix_v2_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_phoenix_v2_free,void,void*
 Function,-,subghz_protocol_decoder_phoenix_v2_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_phoenix_v2_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_phoenix_v2_reset,void,void*
-Function,-,subghz_protocol_decoder_phoenix_v2_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_phoenix_v2_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_power_smart_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_power_smart_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_power_smart_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_power_smart_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_power_smart_free,void,void*
 Function,-,subghz_protocol_decoder_power_smart_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_power_smart_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_power_smart_reset,void,void*
-Function,-,subghz_protocol_decoder_power_smart_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_power_smart_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,+,subghz_protocol_decoder_princeton_alloc,void*,SubGhzEnvironment*
-Function,+,subghz_protocol_decoder_princeton_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_princeton_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,+,subghz_protocol_decoder_princeton_feed,void,"void*, _Bool, uint32_t"
 Function,+,subghz_protocol_decoder_princeton_free,void,void*
 Function,+,subghz_protocol_decoder_princeton_get_hash_data,uint8_t,void*
 Function,+,subghz_protocol_decoder_princeton_get_string,void,"void*, FuriString*"
 Function,+,subghz_protocol_decoder_princeton_reset,void,void*
-Function,+,subghz_protocol_decoder_princeton_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_princeton_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,+,subghz_protocol_decoder_raw_alloc,void*,SubGhzEnvironment*
-Function,+,subghz_protocol_decoder_raw_deserialize,_Bool,"void*, FlipperFormat*"
+Function,+,subghz_protocol_decoder_raw_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,+,subghz_protocol_decoder_raw_feed,void,"void*, _Bool, uint32_t"
 Function,+,subghz_protocol_decoder_raw_free,void,void*
 Function,+,subghz_protocol_decoder_raw_get_string,void,"void*, FuriString*"
 Function,+,subghz_protocol_decoder_raw_reset,void,void*
 Function,-,subghz_protocol_decoder_scher_khan_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_scher_khan_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_scher_khan_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_scher_khan_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_scher_khan_free,void,void*
 Function,-,subghz_protocol_decoder_scher_khan_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_scher_khan_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_scher_khan_reset,void,void*
-Function,-,subghz_protocol_decoder_scher_khan_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_scher_khan_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_secplus_v1_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_secplus_v1_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_secplus_v1_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_secplus_v1_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_secplus_v1_free,void,void*
 Function,-,subghz_protocol_decoder_secplus_v1_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_secplus_v1_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_secplus_v1_reset,void,void*
-Function,-,subghz_protocol_decoder_secplus_v1_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_secplus_v1_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_secplus_v2_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_secplus_v2_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_secplus_v2_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_secplus_v2_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_secplus_v2_free,void,void*
 Function,-,subghz_protocol_decoder_secplus_v2_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_secplus_v2_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_secplus_v2_reset,void,void*
-Function,-,subghz_protocol_decoder_secplus_v2_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_secplus_v2_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_smc5326_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_smc5326_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_smc5326_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_smc5326_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_smc5326_free,void,void*
 Function,-,subghz_protocol_decoder_smc5326_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_smc5326_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_smc5326_reset,void,void*
-Function,-,subghz_protocol_decoder_smc5326_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_smc5326_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_somfy_keytis_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_somfy_keytis_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_somfy_keytis_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_somfy_keytis_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_somfy_keytis_free,void,void*
 Function,-,subghz_protocol_decoder_somfy_keytis_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_somfy_keytis_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_somfy_keytis_reset,void,void*
-Function,-,subghz_protocol_decoder_somfy_keytis_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_somfy_keytis_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_somfy_telis_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_somfy_telis_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_somfy_telis_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_somfy_telis_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_somfy_telis_free,void,void*
 Function,-,subghz_protocol_decoder_somfy_telis_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_somfy_telis_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_somfy_telis_reset,void,void*
-Function,-,subghz_protocol_decoder_somfy_telis_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_somfy_telis_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_decoder_star_line_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_decoder_star_line_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_decoder_star_line_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_decoder_star_line_feed,void,"void*, _Bool, uint32_t"
 Function,-,subghz_protocol_decoder_star_line_free,void,void*
 Function,-,subghz_protocol_decoder_star_line_get_hash_data,uint8_t,void*
 Function,-,subghz_protocol_decoder_star_line_get_string,void,"void*, FuriString*"
 Function,-,subghz_protocol_decoder_star_line_reset,void,void*
-Function,-,subghz_protocol_decoder_star_line_serialize,_Bool,"void*, FlipperFormat*, SubGhzRadioPreset*"
+Function,-,subghz_protocol_decoder_star_line_serialize,SubGhzProtocolStatus,"void*, FlipperFormat*, SubGhzRadioPreset*"
 Function,-,subghz_protocol_encoder_alutech_at_4n_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_alutech_at_4n_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_alutech_at_4n_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_alutech_at_4n_free,void,void*
 Function,-,subghz_protocol_encoder_alutech_at_4n_stop,void,void*
 Function,-,subghz_protocol_encoder_alutech_at_4n_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_ansonic_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_ansonic_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_ansonic_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_ansonic_free,void,void*
 Function,-,subghz_protocol_encoder_ansonic_stop,void,void*
 Function,-,subghz_protocol_encoder_ansonic_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_bett_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_bett_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_bett_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_bett_free,void,void*
 Function,-,subghz_protocol_encoder_bett_stop,void,void*
 Function,-,subghz_protocol_encoder_bett_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_bin_raw_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_bin_raw_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_bin_raw_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_bin_raw_free,void,void*
 Function,-,subghz_protocol_encoder_bin_raw_stop,void,void*
 Function,-,subghz_protocol_encoder_bin_raw_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_came_alloc,void*,SubGhzEnvironment*
 Function,-,subghz_protocol_encoder_came_atomo_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_came_atomo_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_came_atomo_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_came_atomo_free,void,void*
 Function,-,subghz_protocol_encoder_came_atomo_stop,void,void*
 Function,-,subghz_protocol_encoder_came_atomo_yield,LevelDuration,void*
-Function,-,subghz_protocol_encoder_came_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_came_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_came_free,void,void*
 Function,-,subghz_protocol_encoder_came_stop,void,void*
 Function,-,subghz_protocol_encoder_came_twee_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_came_twee_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_came_twee_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_came_twee_free,void,void*
 Function,-,subghz_protocol_encoder_came_twee_stop,void,void*
 Function,-,subghz_protocol_encoder_came_twee_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_came_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_chamb_code_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_chamb_code_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_chamb_code_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_chamb_code_free,void,void*
 Function,-,subghz_protocol_encoder_chamb_code_stop,void,void*
 Function,-,subghz_protocol_encoder_chamb_code_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_clemsa_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_clemsa_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_clemsa_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_clemsa_free,void,void*
 Function,-,subghz_protocol_encoder_clemsa_stop,void,void*
 Function,-,subghz_protocol_encoder_clemsa_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_doitrand_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_doitrand_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_doitrand_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_doitrand_free,void,void*
 Function,-,subghz_protocol_encoder_doitrand_stop,void,void*
 Function,-,subghz_protocol_encoder_doitrand_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_dooya_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_dooya_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_dooya_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_dooya_free,void,void*
 Function,-,subghz_protocol_encoder_dooya_stop,void,void*
 Function,-,subghz_protocol_encoder_dooya_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_faac_slh_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_faac_slh_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_faac_slh_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_faac_slh_free,void,void*
 Function,-,subghz_protocol_encoder_faac_slh_stop,void,void*
 Function,-,subghz_protocol_encoder_faac_slh_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_gate_tx_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_gate_tx_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_gate_tx_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_gate_tx_free,void,void*
 Function,-,subghz_protocol_encoder_gate_tx_stop,void,void*
 Function,-,subghz_protocol_encoder_gate_tx_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_holtek_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_holtek_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_holtek_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_holtek_free,void,void*
 Function,-,subghz_protocol_encoder_holtek_stop,void,void*
 Function,-,subghz_protocol_encoder_holtek_th12x_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_holtek_th12x_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_holtek_th12x_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_holtek_th12x_free,void,void*
 Function,-,subghz_protocol_encoder_holtek_th12x_stop,void,void*
 Function,-,subghz_protocol_encoder_holtek_th12x_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_holtek_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_honeywell_wdb_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_honeywell_wdb_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_honeywell_wdb_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_honeywell_wdb_free,void,void*
 Function,-,subghz_protocol_encoder_honeywell_wdb_stop,void,void*
 Function,-,subghz_protocol_encoder_honeywell_wdb_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_hormann_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_hormann_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_hormann_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_hormann_free,void,void*
 Function,-,subghz_protocol_encoder_hormann_stop,void,void*
 Function,-,subghz_protocol_encoder_hormann_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_intertechno_v3_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_intertechno_v3_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_intertechno_v3_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_intertechno_v3_free,void,void*
 Function,-,subghz_protocol_encoder_intertechno_v3_stop,void,void*
 Function,-,subghz_protocol_encoder_intertechno_v3_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_keeloq_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_keeloq_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_keeloq_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_keeloq_free,void,void*
 Function,-,subghz_protocol_encoder_keeloq_stop,void,void*
 Function,-,subghz_protocol_encoder_keeloq_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_kinggates_stylo_4k_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_kinggates_stylo_4k_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_kinggates_stylo_4k_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_kinggates_stylo_4k_free,void,void*
 Function,-,subghz_protocol_encoder_kinggates_stylo_4k_stop,void,void*
 Function,-,subghz_protocol_encoder_kinggates_stylo_4k_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_linear_alloc,void*,SubGhzEnvironment*
 Function,-,subghz_protocol_encoder_linear_delta3_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_linear_delta3_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_linear_delta3_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_linear_delta3_free,void,void*
 Function,-,subghz_protocol_encoder_linear_delta3_stop,void,void*
 Function,-,subghz_protocol_encoder_linear_delta3_yield,LevelDuration,void*
-Function,-,subghz_protocol_encoder_linear_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_linear_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_linear_free,void,void*
 Function,-,subghz_protocol_encoder_linear_stop,void,void*
 Function,-,subghz_protocol_encoder_linear_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_magellan_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_magellan_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_magellan_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_magellan_free,void,void*
 Function,-,subghz_protocol_encoder_magellan_stop,void,void*
 Function,-,subghz_protocol_encoder_magellan_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_marantec_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_marantec_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_marantec_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_marantec_free,void,void*
 Function,-,subghz_protocol_encoder_marantec_stop,void,void*
 Function,-,subghz_protocol_encoder_marantec_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_megacode_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_megacode_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_megacode_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_megacode_free,void,void*
 Function,-,subghz_protocol_encoder_megacode_stop,void,void*
 Function,-,subghz_protocol_encoder_megacode_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_nero_radio_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_nero_radio_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_nero_radio_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_nero_radio_free,void,void*
 Function,-,subghz_protocol_encoder_nero_radio_stop,void,void*
 Function,-,subghz_protocol_encoder_nero_radio_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_nero_sketch_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_nero_sketch_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_nero_sketch_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_nero_sketch_free,void,void*
 Function,-,subghz_protocol_encoder_nero_sketch_stop,void,void*
 Function,-,subghz_protocol_encoder_nero_sketch_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_nice_flo_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_nice_flo_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_nice_flo_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_nice_flo_free,void,void*
 Function,-,subghz_protocol_encoder_nice_flo_stop,void,void*
 Function,-,subghz_protocol_encoder_nice_flo_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_nice_flor_s_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_nice_flor_s_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_nice_flor_s_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_nice_flor_s_free,void,void*
 Function,-,subghz_protocol_encoder_nice_flor_s_stop,void,void*
 Function,-,subghz_protocol_encoder_nice_flor_s_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_phoenix_v2_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_phoenix_v2_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_phoenix_v2_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_phoenix_v2_free,void,void*
 Function,-,subghz_protocol_encoder_phoenix_v2_stop,void,void*
 Function,-,subghz_protocol_encoder_phoenix_v2_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_power_smart_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_power_smart_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_power_smart_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_power_smart_free,void,void*
 Function,-,subghz_protocol_encoder_power_smart_stop,void,void*
 Function,-,subghz_protocol_encoder_power_smart_yield,LevelDuration,void*
 Function,+,subghz_protocol_encoder_princeton_alloc,void*,SubGhzEnvironment*
-Function,+,subghz_protocol_encoder_princeton_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_princeton_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,+,subghz_protocol_encoder_princeton_free,void,void*
 Function,+,subghz_protocol_encoder_princeton_stop,void,void*
 Function,+,subghz_protocol_encoder_princeton_yield,LevelDuration,void*
 Function,+,subghz_protocol_encoder_raw_alloc,void*,SubGhzEnvironment*
-Function,+,subghz_protocol_encoder_raw_deserialize,_Bool,"void*, FlipperFormat*"
+Function,+,subghz_protocol_encoder_raw_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,+,subghz_protocol_encoder_raw_free,void,void*
 Function,+,subghz_protocol_encoder_raw_stop,void,void*
 Function,+,subghz_protocol_encoder_raw_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_secplus_v1_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_secplus_v1_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_secplus_v1_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_secplus_v1_free,void,void*
 Function,-,subghz_protocol_encoder_secplus_v1_stop,void,void*
 Function,-,subghz_protocol_encoder_secplus_v1_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_secplus_v2_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_secplus_v2_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_secplus_v2_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_secplus_v2_free,void,void*
 Function,-,subghz_protocol_encoder_secplus_v2_stop,void,void*
 Function,-,subghz_protocol_encoder_secplus_v2_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_smc5326_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_smc5326_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_smc5326_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_smc5326_free,void,void*
 Function,-,subghz_protocol_encoder_smc5326_stop,void,void*
 Function,-,subghz_protocol_encoder_smc5326_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_somfy_keytis_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_somfy_keytis_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_somfy_keytis_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_somfy_keytis_free,void,void*
 Function,-,subghz_protocol_encoder_somfy_keytis_stop,void,void*
 Function,-,subghz_protocol_encoder_somfy_keytis_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_somfy_telis_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_somfy_telis_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_somfy_telis_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_somfy_telis_free,void,void*
 Function,-,subghz_protocol_encoder_somfy_telis_stop,void,void*
 Function,-,subghz_protocol_encoder_somfy_telis_yield,LevelDuration,void*
 Function,-,subghz_protocol_encoder_star_line_alloc,void*,SubGhzEnvironment*
-Function,-,subghz_protocol_encoder_star_line_deserialize,_Bool,"void*, FlipperFormat*"
+Function,-,subghz_protocol_encoder_star_line_deserialize,SubGhzProtocolStatus,"void*, FlipperFormat*"
 Function,-,subghz_protocol_encoder_star_line_free,void,void*
 Function,-,subghz_protocol_encoder_star_line_stop,void,void*
 Function,-,subghz_protocol_encoder_star_line_yield,LevelDuration,void*
@@ -3239,7 +3259,7 @@ Function,+,subghz_setting_load,void,"SubGhzSetting*, const char*"
 Function,+,subghz_setting_load_custom_preset,_Bool,"SubGhzSetting*, const char*, FlipperFormat*"
 Function,+,subghz_setting_set_default_frequency,void,"SubGhzSetting*, uint32_t"
 Function,+,subghz_transmitter_alloc_init,SubGhzTransmitter*,"SubGhzEnvironment*, const char*"
-Function,+,subghz_transmitter_deserialize,_Bool,"SubGhzTransmitter*, FlipperFormat*"
+Function,+,subghz_transmitter_deserialize,SubGhzProtocolStatus,"SubGhzTransmitter*, FlipperFormat*"
 Function,+,subghz_transmitter_free,void,SubGhzTransmitter*
 Function,+,subghz_transmitter_get_protocol_instance,SubGhzProtocolEncoderBase*,SubGhzTransmitter*
 Function,+,subghz_transmitter_stop,_Bool,SubGhzTransmitter*
@@ -4584,7 +4604,6 @@ Function,+,widget_alloc,Widget*,
 Function,+,widget_free,void,Widget*
 Function,+,widget_get_view,View*,Widget*
 Function,+,widget_reset,void,Widget*
-Function,-,write_mutex,_Bool,"ValueMutex*, void*, size_t, uint32_t"
 Function,-,xPortGetFreeHeapSize,size_t,
 Function,-,xPortGetMinimumEverFreeHeapSize,size_t,
 Function,-,xPortStartScheduler,BaseType_t,
diff --git a/firmware/targets/f7/fatfs/sd_spi_io.c b/firmware/targets/f7/fatfs/sd_spi_io.c
index 68903acfb6..e8e542b32e 100644
--- a/firmware/targets/f7/fatfs/sd_spi_io.c
+++ b/firmware/targets/f7/fatfs/sd_spi_io.c
@@ -585,6 +585,8 @@ static SdSpiStatus sd_spi_get_cid(SD_CID* Cid) {
             Cid->ProdSN |= cid_data[12];
             Cid->Reserved1 = (cid_data[13] & 0xF0) >> 4;
             Cid->ManufactYear = (cid_data[13] & 0x0F) << 4;
+            Cid->ManufactYear |= (cid_data[14] & 0xF0) >> 4;
+            Cid->ManufactMonth = (cid_data[14] & 0x0F);
             Cid->CID_CRC = (cid_data[15] & 0xFE) >> 1;
             Cid->Reserved2 = 1;
 
diff --git a/firmware/targets/f7/furi_hal/furi_hal_subghz.c b/firmware/targets/f7/furi_hal/furi_hal_subghz.c
index 451cda4397..1814453728 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_subghz.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_subghz.c
@@ -21,7 +21,6 @@
 #define INIT_TIMEOUT 10
 
 static uint32_t furi_hal_subghz_debug_gpio_buff[2];
-static bool last_OTG_state = false;
 
 /* DMA Channels definition */
 #define SUBGHZ_DMA DMA2
@@ -40,6 +39,7 @@ volatile FuriHalSubGhz furi_hal_subghz = {
     .spi_bus_handle = &furi_hal_spi_bus_handle_subghz,
     .cc1101_g0_pin = &gpio_cc1101_g0,
     .rolling_counter_mult = 1,
+    .ext_module_power_disabled = false,
 };
 
 bool furi_hal_subghz_set_radio_type(SubGhzRadioType state) {
@@ -71,6 +71,14 @@ void furi_hal_subghz_set_rolling_counter_mult(uint8_t mult) {
     furi_hal_subghz.rolling_counter_mult = mult;
 }
 
+void furi_hal_subghz_set_external_power_disable(bool state) {
+    furi_hal_subghz.ext_module_power_disabled = state;
+}
+
+bool furi_hal_subghz_get_external_power_disable(void) {
+    return furi_hal_subghz.ext_module_power_disabled;
+}
+
 void furi_hal_subghz_set_async_mirror_pin(const GpioPin* pin) {
     furi_hal_subghz.async_mirror_pin = pin;
 }
@@ -79,14 +87,23 @@ void furi_hal_subghz_init(void) {
     furi_hal_subghz_init_check();
 }
 
-void furi_hal_subghz_enable_ext_power(void) {
-    if(furi_hal_subghz.radio_type != SubGhzRadioInternal && !furi_hal_power_is_otg_enabled()) {
-        furi_hal_power_enable_otg();
+bool furi_hal_subghz_enable_ext_power(void) {
+    if(furi_hal_subghz.ext_module_power_disabled) {
+        return false;
     }
+    if(furi_hal_subghz.radio_type != SubGhzRadioInternal) {
+        uint8_t attempts = 0;
+        while(!furi_hal_power_is_otg_enabled() && attempts++ < 2) {
+            furi_hal_power_enable_otg();
+            //CC1101 power-up time
+            furi_delay_ms(5);
+        }
+    }
+    return furi_hal_power_is_otg_enabled();
 }
 
 void furi_hal_subghz_disable_ext_power(void) {
-    if(furi_hal_subghz.radio_type != SubGhzRadioInternal && !last_OTG_state) {
+    if(furi_hal_power_is_otg_enabled()) {
         furi_hal_power_disable_otg();
     }
 }
@@ -94,9 +111,8 @@ void furi_hal_subghz_disable_ext_power(void) {
 bool furi_hal_subghz_check_radio(void) {
     bool result = true;
 
-    furi_hal_subghz_enable_ext_power();
-
     furi_hal_spi_acquire(furi_hal_subghz.spi_bus_handle);
+
     uint8_t ver = cc1101_get_version(furi_hal_subghz.spi_bus_handle);
     furi_hal_spi_release(furi_hal_subghz.spi_bus_handle);
 
@@ -104,7 +120,7 @@ bool furi_hal_subghz_check_radio(void) {
         FURI_LOG_D(TAG, "Radio check ok");
     } else {
         FURI_LOG_D(TAG, "Radio check failed");
-        furi_hal_subghz_disable_ext_power();
+
         result = false;
     }
     return result;
@@ -117,8 +133,6 @@ bool furi_hal_subghz_init_check(void) {
     furi_hal_subghz.state = SubGhzStateIdle;
     furi_hal_subghz.preset = FuriHalSubGhzPresetIDLE;
 
-    last_OTG_state = furi_hal_power_is_otg_enabled();
-    furi_hal_subghz_enable_ext_power();
     furi_hal_spi_acquire(furi_hal_subghz.spi_bus_handle);
 
 #ifdef FURI_HAL_SUBGHZ_TX_GPIO
@@ -169,7 +183,6 @@ bool furi_hal_subghz_init_check(void) {
         FURI_LOG_I(TAG, "Init OK");
     } else {
         FURI_LOG_E(TAG, "Failed to initialization");
-        furi_hal_subghz_disable_ext_power();
     }
     return result;
 }
@@ -187,8 +200,6 @@ void furi_hal_subghz_sleep() {
 
     furi_hal_spi_release(furi_hal_subghz.spi_bus_handle);
 
-    furi_hal_subghz_disable_ext_power();
-
     furi_hal_subghz.preset = FuriHalSubGhzPresetIDLE;
 }
 
@@ -333,7 +344,6 @@ void furi_hal_subghz_shutdown() {
     // Reset and shutdown
     cc1101_shutdown(furi_hal_subghz.spi_bus_handle);
     furi_hal_spi_release(furi_hal_subghz.spi_bus_handle);
-    furi_hal_subghz_disable_ext_power();
 }
 
 void furi_hal_subghz_reset() {
diff --git a/firmware/targets/f7/furi_hal/furi_hal_subghz.h b/firmware/targets/f7/furi_hal/furi_hal_subghz.h
index 8ede17d320..ec886f6939 100644
--- a/firmware/targets/f7/furi_hal/furi_hal_subghz.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_subghz.h
@@ -78,6 +78,7 @@ typedef struct {
     FuriHalSpiBusHandle* spi_bus_handle;
     const GpioPin* cc1101_g0_pin;
     uint8_t rolling_counter_mult;
+    bool ext_module_power_disabled;
 } FuriHalSubGhz;
 
 extern volatile FuriHalSubGhz furi_hal_subghz;
@@ -303,8 +304,9 @@ SubGhzRadioType furi_hal_subghz_get_radio_type(void);
 bool furi_hal_subghz_check_radio(void);
 
 /** Turn on the power of the external radio module
+ * @return     true if power-up is successful
  */
-void furi_hal_subghz_enable_ext_power(void);
+bool furi_hal_subghz_enable_ext_power(void);
 
 /** Turn off the power of the external radio module
  */
@@ -320,6 +322,14 @@ uint8_t furi_hal_subghz_get_rolling_counter_mult(void);
  */
 void furi_hal_subghz_set_rolling_counter_mult(uint8_t mult);
 
+/** If true - disable 5v power of the external radio module
+ */
+void furi_hal_subghz_set_external_power_disable(bool state);
+
+/** Get the current state of the external power disable flag
+ */
+bool furi_hal_subghz_get_external_power_disable(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/firmware/targets/f7/src/recovery.c b/firmware/targets/f7/src/recovery.c
index d56be4fe07..db538b0d51 100644
--- a/firmware/targets/f7/src/recovery.c
+++ b/firmware/targets/f7/src/recovery.c
@@ -5,24 +5,20 @@
 #include <u8g2_glue.h>
 #include <assets_icons.h>
 
-#define COUNTER_VALUE (100U)
+#define COUNTER_VALUE (136U)
 
 static void flipper_boot_recovery_draw_splash(u8g2_t* fb, size_t progress) {
-    u8g2_ClearBuffer(fb);
-    u8g2_SetDrawColor(fb, 0x01);
-
-    u8g2_SetFont(fb, u8g2_font_helvB08_tr);
-    u8g2_DrawStr(fb, 2, 8, "PIN and Factory Reset");
-    u8g2_SetFont(fb, u8g2_font_haxrcorp4089_tr);
-    u8g2_DrawStr(fb, 2, 21, "Hold Right to confirm");
-    u8g2_DrawStr(fb, 2, 31, "Press Down to cancel");
-
     if(progress < COUNTER_VALUE) {
-        size_t width = progress / (COUNTER_VALUE / 100);
-        u8g2_DrawBox(fb, 14 + (50 - width / 2), 54, width, 3);
+        // Fill the progress bar while the progress is going down
+        u8g2_SetDrawColor(fb, 0x01);
+        u8g2_DrawRFrame(fb, 59, 41, 69, 8, 2);
+        size_t width = (COUNTER_VALUE - progress) * 68 / COUNTER_VALUE;
+        u8g2_DrawBox(fb, 60, 42, width, 6);
+    } else {
+        u8g2_SetDrawColor(fb, 0x00);
+        u8g2_DrawRBox(fb, 59, 41, 69, 8, 2);
     }
 
-    u8g2_SetPowerSave(fb, 0);
     u8g2_SendBuffer(fb);
 }
 
@@ -31,6 +27,18 @@ void flipper_boot_recovery_exec() {
     u8g2_Setup_st756x_flipper(fb, U8G2_R0, u8x8_hw_spi_stm32, u8g2_gpio_and_delay_stm32);
     u8g2_InitDisplay(fb);
 
+    furi_hal_compress_icon_init();
+    uint8_t* splash_data = NULL;
+    furi_hal_compress_icon_decode(icon_get_data(&I_Erase_pin_128x64), &splash_data);
+
+    u8g2_ClearBuffer(fb);
+    u8g2_SetDrawColor(fb, 0x01);
+
+    // Draw the recovery picture
+    u8g2_DrawXBM(fb, 0, 0, 128, 64, splash_data);
+    u8g2_SendBuffer(fb);
+    u8g2_SetPowerSave(fb, 0);
+
     size_t counter = COUNTER_VALUE;
     while(counter) {
         if(!furi_hal_gpio_read(&gpio_button_down)) {
diff --git a/furi/core/thread.c b/furi/core/thread.c
index ea9f45e842..b45651c29d 100644
--- a/furi/core/thread.c
+++ b/furi/core/thread.c
@@ -35,6 +35,8 @@ struct FuriThread {
     void* state_context;
 
     char* name;
+    char* appid;
+
     configSTACK_DEPTH_TYPE stack_size;
     FuriThreadPriority priority;
 
@@ -122,11 +124,25 @@ FuriThread* furi_thread_alloc() {
     thread->output.buffer = furi_string_alloc();
     thread->is_service = false;
 
+    FuriThread* parent = NULL;
+    if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
+        // TLS is not available, if we called not from thread context
+        parent = pvTaskGetThreadLocalStoragePointer(NULL, 0);
+
+        if(parent && parent->appid) {
+            furi_thread_set_appid(thread, parent->appid);
+        } else {
+            furi_thread_set_appid(thread, "unknown");
+        }
+    } else {
+        // if scheduler is not started, we are starting driver thread
+        furi_thread_set_appid(thread, "driver");
+    }
+
     FuriHalRtcHeapTrackMode mode = furi_hal_rtc_get_heap_track_mode();
     if(mode == FuriHalRtcHeapTrackModeAll) {
         thread->heap_trace_enabled = true;
     } else if(mode == FuriHalRtcHeapTrackModeTree && furi_thread_get_current_id()) {
-        FuriThread* parent = pvTaskGetThreadLocalStoragePointer(NULL, 0);
         if(parent) thread->heap_trace_enabled = parent->heap_trace_enabled;
     } else {
         thread->heap_trace_enabled = false;
@@ -153,6 +169,7 @@ void furi_thread_free(FuriThread* thread) {
     furi_assert(thread->state == FuriThreadStateStopped);
 
     if(thread->name) free((void*)thread->name);
+    if(thread->appid) free((void*)thread->appid);
     furi_string_free(thread->output.buffer);
 
     free(thread);
@@ -165,6 +182,13 @@ void furi_thread_set_name(FuriThread* thread, const char* name) {
     thread->name = name ? strdup(name) : NULL;
 }
 
+void furi_thread_set_appid(FuriThread* thread, const char* appid) {
+    furi_assert(thread);
+    furi_assert(thread->state == FuriThreadStateStopped);
+    if(thread->appid) free((void*)thread->appid);
+    thread->appid = appid ? strdup(appid) : NULL;
+}
+
 void furi_thread_mark_as_service(FuriThread* thread) {
     thread->is_service = true;
 }
@@ -498,6 +522,20 @@ const char* furi_thread_get_name(FuriThreadId thread_id) {
     return (name);
 }
 
+const char* furi_thread_get_appid(FuriThreadId thread_id) {
+    TaskHandle_t hTask = (TaskHandle_t)thread_id;
+    const char* appid = "system";
+
+    if(!FURI_IS_IRQ_MODE() && (hTask != NULL)) {
+        FuriThread* thread = (FuriThread*)pvTaskGetThreadLocalStoragePointer(hTask, 0);
+        if(thread) {
+            appid = thread->appid;
+        }
+    }
+
+    return (appid);
+}
+
 uint32_t furi_thread_get_stack_space(FuriThreadId thread_id) {
     TaskHandle_t hTask = (TaskHandle_t)thread_id;
     uint32_t sz;
diff --git a/furi/core/thread.h b/furi/core/thread.h
index 2675f7cee7..8f43984197 100644
--- a/furi/core/thread.h
+++ b/furi/core/thread.h
@@ -87,6 +87,16 @@ void furi_thread_free(FuriThread* thread);
  */
 void furi_thread_set_name(FuriThread* thread, const char* name);
 
+/**
+ * @brief Set FuriThread appid
+ * Technically, it is like a "process id", but it is not a system-wide unique identifier.
+ * All threads spawned by the same app will have the same appid.
+ * 
+ * @param thread 
+ * @param appid 
+ */
+void furi_thread_set_appid(FuriThread* thread, const char* appid);
+
 /** Mark thread as service
  * The service cannot be stopped or removed, and cannot exit from the thread body
  * 
@@ -233,10 +243,37 @@ uint32_t furi_thread_flags_get(void);
 
 uint32_t furi_thread_flags_wait(uint32_t flags, uint32_t options, uint32_t timeout);
 
+/**
+ * @brief Enumerate threads
+ * 
+ * @param thread_array array of FuriThreadId, where thread ids will be stored
+ * @param array_items array size
+ * @return uint32_t threads count
+ */
 uint32_t furi_thread_enumerate(FuriThreadId* thread_array, uint32_t array_items);
 
+/**
+ * @brief Get thread name
+ * 
+ * @param thread_id 
+ * @return const char* name or NULL
+ */
 const char* furi_thread_get_name(FuriThreadId thread_id);
 
+/**
+ * @brief Get thread appid
+ * 
+ * @param thread_id 
+ * @return const char* appid
+ */
+const char* furi_thread_get_appid(FuriThreadId thread_id);
+
+/**
+ * @brief Get thread stack watermark
+ * 
+ * @param thread_id 
+ * @return uint32_t 
+ */
 uint32_t furi_thread_get_stack_space(FuriThreadId thread_id);
 
 /** Get STDOUT callback for thead
diff --git a/furi/core/valuemutex.c b/furi/core/valuemutex.c
deleted file mode 100644
index bf4e6130bd..0000000000
--- a/furi/core/valuemutex.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "valuemutex.h"
-
-#include <string.h>
-
-bool init_mutex(ValueMutex* valuemutex, void* value, size_t size) {
-    // mutex without name,
-    // no attributes (unfortunately robust mutex is not supported by FreeRTOS),
-    // with dynamic memory allocation
-    valuemutex->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-    if(valuemutex->mutex == NULL) return false;
-
-    valuemutex->value = value;
-    valuemutex->size = size;
-
-    return true;
-}
-
-bool delete_mutex(ValueMutex* valuemutex) {
-    if(furi_mutex_acquire(valuemutex->mutex, FuriWaitForever) == FuriStatusOk) {
-        furi_mutex_free(valuemutex->mutex);
-        return true;
-    } else {
-        return false;
-    }
-}
-
-void* acquire_mutex(ValueMutex* valuemutex, uint32_t timeout) {
-    if(furi_mutex_acquire(valuemutex->mutex, timeout) == FuriStatusOk) {
-        return valuemutex->value;
-    } else {
-        return NULL;
-    }
-}
-
-bool release_mutex(ValueMutex* valuemutex, const void* value) {
-    if(value != valuemutex->value) return false;
-
-    if(furi_mutex_release(valuemutex->mutex) != FuriStatusOk) return false;
-
-    return true;
-}
-
-bool read_mutex(ValueMutex* valuemutex, void* data, size_t len, uint32_t timeout) {
-    void* value = acquire_mutex(valuemutex, timeout);
-    if(value == NULL || len > valuemutex->size) return false;
-    memcpy(data, value, len > 0 ? len : valuemutex->size);
-    if(!release_mutex(valuemutex, value)) return false;
-
-    return true;
-}
-
-bool write_mutex(ValueMutex* valuemutex, void* data, size_t len, uint32_t timeout) {
-    void* value = acquire_mutex(valuemutex, timeout);
-    if(value == NULL || len > valuemutex->size) return false;
-    memcpy(value, data, len > 0 ? len : valuemutex->size);
-    if(!release_mutex(valuemutex, value)) return false;
-
-    return true;
-}
diff --git a/furi/core/valuemutex.h b/furi/core/valuemutex.h
deleted file mode 100644
index 0d867a1df2..0000000000
--- a/furi/core/valuemutex.h
+++ /dev/null
@@ -1,149 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include "mutex.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * == ValueMutex ==
-
- * The most simple concept is ValueMutex.
- * It is wrapper around mutex and value pointer.
- * You can take and give mutex to work with value and read and write value.
- */
-
-typedef struct {
-    void* value;
-    size_t size;
-    FuriMutex* mutex;
-} ValueMutex;
-
-/**
- * Creates ValueMutex.
- */
-bool init_mutex(ValueMutex* valuemutex, void* value, size_t size);
-
-/**
- * Free resources allocated by `init_mutex`.
- * This function doesn't free the memory occupied by `ValueMutex` itself.
- */
-bool delete_mutex(ValueMutex* valuemutex);
-
-/**
- * Call for work with data stored in mutex.
- * @return pointer to data if success, NULL otherwise.
- */
-void* acquire_mutex(ValueMutex* valuemutex, uint32_t timeout);
-
-/**
- * Helper: infinitely wait for mutex
- */
-static inline void* acquire_mutex_block(ValueMutex* valuemutex) {
-    return acquire_mutex(valuemutex, FuriWaitForever);
-}
-
-/**
- * With statement for value mutex, acts as lambda
- * @param name a resource name, const char*
- * @param function_body a (){} lambda declaration,
- * executed within you parent function context.
- */
-#define with_value_mutex(value_mutex, function_body) \
-    {                                                \
-        void* p = acquire_mutex_block(value_mutex);  \
-        furi_check(p);                               \
-        ({ void __fn__ function_body __fn__; })(p);  \
-        release_mutex(value_mutex, p);               \
-    }
-
-/**
- * Release mutex after end of work with data.
- * Call `release_mutex` and pass ValueData instance and pointer to data.
- */
-bool release_mutex(ValueMutex* valuemutex, const void* value);
-
-/**
- * Instead of take-access-give sequence you can use `read_mutex` and `write_mutex` functions.
- * Both functions return true in case of success, false otherwise.
- */
-bool read_mutex(ValueMutex* valuemutex, void* data, size_t len, uint32_t timeout);
-
-bool write_mutex(ValueMutex* valuemutex, void* data, size_t len, uint32_t timeout);
-
-inline static bool write_mutex_block(ValueMutex* valuemutex, void* data, size_t len) {
-    return write_mutex(valuemutex, data, len, FuriWaitForever);
-}
-
-inline static bool read_mutex_block(ValueMutex* valuemutex, void* data, size_t len) {
-    return read_mutex(valuemutex, data, len, FuriWaitForever);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
-
-Usage example
-
-```C
-// MANIFEST
-// name="example-provider-app"
-// stack=128
-
-void provider_app(void* _p) {
-    // create record with mutex
-    uint32_t example_value = 0;
-    ValueMutex example_mutex;
-    // call `init_mutex`.
-    if(!init_mutex(&example_mutex, (void*)&example_value, sizeof(uint32_t))) {
-        printf("critical error\n");
-        flapp_exit(NULL);
-    }
-
-    furi_record_create("provider/example", (void*)&example_mutex);
-
-    // we are ready to provide record to other apps
-    flapp_ready();
-
-    // get value and increment it
-    while(1) {
-        uint32_t* value = acquire_mutex(&example_mutex, OsWaitForever);
-        if(value != NULL) {
-            value++;
-        }
-        release_mutex(&example_mutex, value);
-
-        furi_delay_ms(100);
-    }
-}
-
-// MANIFEST
-// name="example-consumer-app"
-// stack=128
-// require="example-provider-app"
-void consumer_app(void* _p) {
-    // this app run after flapp_ready call in all requirements app
-
-    // open mutex value
-    ValueMutex* counter_mutex = furi_record_open("provider/example");
-    if(counter_mutex == NULL) {
-        printf("critical error\n");
-        flapp_exit(NULL);
-    }
-
-    // continuously read value every 1s
-    uint32_t counter;
-    while(1) {
-        if(read_mutex(counter_mutex, &counter, sizeof(counter), OsWaitForever)) {
-            printf("counter value: %d\n", counter);
-        }
-
-        furi_delay_ms(1000);
-    }
-}
-```
-*/
diff --git a/furi/flipper.c b/furi/flipper.c
index d16a84a101..f0147c0602 100644
--- a/furi/flipper.c
+++ b/furi/flipper.c
@@ -41,6 +41,7 @@ void flipper_init() {
             FLIPPER_SERVICES[i].app,
             NULL);
         furi_thread_mark_as_service(thread);
+        furi_thread_set_appid(thread, FLIPPER_SERVICES[i].appid);
 
         furi_thread_start(thread);
     }
diff --git a/furi/furi.h b/furi/furi.h
index 3ce8342274..cfdeb2c0f4 100644
--- a/furi/furi.h
+++ b/furi/furi.h
@@ -16,7 +16,6 @@
 #include "core/semaphore.h"
 #include "core/thread.h"
 #include "core/timer.h"
-#include "core/valuemutex.h"
 #include "core/string.h"
 #include "core/stream_buffer.h"
 
diff --git a/lib/flipper_format/flipper_format.c b/lib/flipper_format/flipper_format.c
index 292dab5f1b..bb1aa59f58 100644
--- a/lib/flipper_format/flipper_format.c
+++ b/lib/flipper_format/flipper_format.c
@@ -91,6 +91,12 @@ bool flipper_format_file_open_always(FlipperFormat* flipper_format, const char*
     return file_stream_open(flipper_format->stream, path, FSAM_READ_WRITE, FSOM_CREATE_ALWAYS);
 }
 
+bool flipper_format_buffered_file_open_always(FlipperFormat* flipper_format, const char* path) {
+    furi_assert(flipper_format);
+    return buffered_file_stream_open(
+        flipper_format->stream, path, FSAM_READ_WRITE, FSOM_CREATE_ALWAYS);
+}
+
 bool flipper_format_file_open_new(FlipperFormat* flipper_format, const char* path) {
     furi_assert(flipper_format);
     return file_stream_open(flipper_format->stream, path, FSAM_READ_WRITE, FSOM_CREATE_NEW);
diff --git a/lib/flipper_format/flipper_format.h b/lib/flipper_format/flipper_format.h
index 743918e3bc..671ff6fa0c 100644
--- a/lib/flipper_format/flipper_format.h
+++ b/lib/flipper_format/flipper_format.h
@@ -131,7 +131,7 @@ bool flipper_format_file_open_existing(FlipperFormat* flipper_format, const char
 
 /**
  * Open existing file, buffered mode.
- * Use only if FlipperFormat allocated as a file.
+ * Use only if FlipperFormat allocated as a buffered file.
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param path File path
  * @return True on success
@@ -156,6 +156,15 @@ bool flipper_format_file_open_append(FlipperFormat* flipper_format, const char*
  */
 bool flipper_format_file_open_always(FlipperFormat* flipper_format, const char* path);
 
+/**
+ * Open file. Creates a new file, or deletes the contents of the file if it already exists, buffered mode.
+ * Use only if FlipperFormat allocated as a buffered file.
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param path File path
+ * @return True on success
+ */
+bool flipper_format_buffered_file_open_always(FlipperFormat* flipper_format, const char* path);
+
 /**
  * Open file. Creates a new file, fails if file already exists.
  * Use only if FlipperFormat allocated as a file.
diff --git a/lib/nfc/nfc_worker.c b/lib/nfc/nfc_worker.c
index 54bdbb24ca..062a395343 100644
--- a/lib/nfc/nfc_worker.c
+++ b/lib/nfc/nfc_worker.c
@@ -569,6 +569,32 @@ void nfc_worker_emulate_mf_ultralight(NfcWorker* nfc_worker) {
     }
 }
 
+static bool nfc_worker_mf_get_b_key_from_sector_trailer(
+    FuriHalNfcTxRxContext* tx_rx,
+    uint16_t sector,
+    uint64_t key,
+    uint64_t* found_key) {
+    // Some access conditions allow reading B key via A key
+
+    uint8_t block = mf_classic_get_sector_trailer_block_num_by_sector(sector);
+
+    Crypto1 crypto = {};
+    MfClassicBlock block_tmp = {};
+    MfClassicAuthContext auth_context = {.sector = sector, .key_a = MF_CLASSIC_NO_KEY, .key_b = 0};
+
+    furi_hal_nfc_sleep();
+
+    if(mf_classic_auth_attempt(tx_rx, &crypto, &auth_context, key)) {
+        if(mf_classic_read_block(tx_rx, &crypto, block, &block_tmp)) {
+            *found_key = nfc_util_bytes2num(&block_tmp.value[10], sizeof(uint8_t) * 6);
+
+            return *found_key;
+        }
+    }
+
+    return false;
+}
+
 static void nfc_worker_mf_classic_key_attack(
     NfcWorker* nfc_worker,
     uint64_t key,
@@ -614,6 +640,16 @@ static void nfc_worker_mf_classic_key_attack(
                     mf_classic_set_key_found(data, i, MfClassicKeyA, key);
                     FURI_LOG_D(TAG, "Key found");
                     nfc_worker->callback(NfcWorkerEventFoundKeyA, nfc_worker->context);
+
+                    uint64_t found_key;
+                    if(nfc_worker_mf_get_b_key_from_sector_trailer(tx_rx, i, key, &found_key)) {
+                        FURI_LOG_D(TAG, "Found B key via reading sector %d", i);
+                        mf_classic_set_key_found(data, i, MfClassicKeyB, found_key);
+
+                        if(nfc_worker->state == NfcWorkerStateMfClassicDictAttack) {
+                            nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
+                        }
+                    }
                 }
             }
             if(!mf_classic_is_key_found(data, i, MfClassicKeyB)) {
@@ -705,6 +741,19 @@ void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker) {
                         mf_classic_set_key_found(data, i, MfClassicKeyA, key);
                         FURI_LOG_D(TAG, "Key found");
                         nfc_worker->callback(NfcWorkerEventFoundKeyA, nfc_worker->context);
+
+                        uint64_t found_key;
+                        if(nfc_worker_mf_get_b_key_from_sector_trailer(
+                               &tx_rx, i, key, &found_key)) {
+                            FURI_LOG_D(TAG, "Found B key via reading sector %d", i);
+                            mf_classic_set_key_found(data, i, MfClassicKeyB, found_key);
+
+                            if(nfc_worker->state == NfcWorkerStateMfClassicDictAttack) {
+                                nfc_worker->callback(NfcWorkerEventFoundKeyB, nfc_worker->context);
+                            }
+
+                            nfc_worker_mf_classic_key_attack(nfc_worker, found_key, &tx_rx, i + 1);
+                        }
                         nfc_worker_mf_classic_key_attack(nfc_worker, key, &tx_rx, i + 1);
                     }
                     furi_hal_nfc_sleep();
diff --git a/lib/nfc/protocols/mifare_classic.c b/lib/nfc/protocols/mifare_classic.c
index e4d5e0274b..a8a908897d 100644
--- a/lib/nfc/protocols/mifare_classic.c
+++ b/lib/nfc/protocols/mifare_classic.c
@@ -541,6 +541,7 @@ bool mf_classic_authenticate_skip_activate(
 
 bool mf_classic_auth_attempt(
     FuriHalNfcTxRxContext* tx_rx,
+    Crypto1* crypto,
     MfClassicAuthContext* auth_ctx,
     uint64_t key) {
     furi_assert(tx_rx);
@@ -549,15 +550,14 @@ bool mf_classic_auth_attempt(
     bool need_halt = (auth_ctx->key_a == MF_CLASSIC_NO_KEY) &&
                      (auth_ctx->key_b == MF_CLASSIC_NO_KEY);
 
-    Crypto1 crypto;
     if(auth_ctx->key_a == MF_CLASSIC_NO_KEY) {
         // Try AUTH with key A
         if(mf_classic_auth(
                tx_rx,
-               mf_classic_get_first_block_num_of_sector(auth_ctx->sector),
+               mf_classic_get_sector_trailer_block_num_by_sector(auth_ctx->sector),
                key,
                MfClassicKeyA,
-               &crypto,
+               crypto,
                false,
                0)) {
             auth_ctx->key_a = key;
@@ -573,10 +573,10 @@ bool mf_classic_auth_attempt(
         // Try AUTH with key B
         if(mf_classic_auth(
                tx_rx,
-               mf_classic_get_first_block_num_of_sector(auth_ctx->sector),
+               mf_classic_get_sector_trailer_block_num_by_sector(auth_ctx->sector),
                key,
                MfClassicKeyB,
-               &crypto,
+               crypto,
                false,
                0)) {
             auth_ctx->key_b = key;
@@ -671,6 +671,9 @@ void mf_classic_read_sector(FuriHalNfcTxRxContext* tx_rx, MfClassicData* data, u
     do {
         if(blocks_read == total_blocks) break;
         if(!key_b_found) break;
+        if(key_a_found) {
+            furi_hal_nfc_sleep();
+        }
         FURI_LOG_D(TAG, "Try to read blocks with key B");
         key = nfc_util_bytes2num(sec_tr->key_b, sizeof(sec_tr->key_b));
         if(!mf_classic_auth(tx_rx, start_block, key, MfClassicKeyB, &crypto, false, 0)) break;
diff --git a/lib/nfc/protocols/mifare_classic.h b/lib/nfc/protocols/mifare_classic.h
index a88781f9c8..c03350f2e9 100644
--- a/lib/nfc/protocols/mifare_classic.h
+++ b/lib/nfc/protocols/mifare_classic.h
@@ -174,6 +174,7 @@ bool mf_classic_authenticate_skip_activate(
 
 bool mf_classic_auth_attempt(
     FuriHalNfcTxRxContext* tx_rx,
+    Crypto1* crypto,
     MfClassicAuthContext* auth_ctx,
     uint64_t key);
 
diff --git a/lib/one_wire/SConscript b/lib/one_wire/SConscript
index 5e06d21e39..56d4759ebe 100644
--- a/lib/one_wire/SConscript
+++ b/lib/one_wire/SConscript
@@ -11,8 +11,9 @@ env.Append(
         File("one_wire_host_timing.h"),
         File("one_wire_host.h"),
         File("one_wire_slave.h"),
-        File("one_wire_device.h"),
+        File("ibutton/ibutton_key.h"),
         File("ibutton/ibutton_worker.h"),
+        File("ibutton/ibutton_protocols.h"),
         File("maxim_crc.h"),
     ],
 )
diff --git a/lib/one_wire/ibutton/ibutton_key.c b/lib/one_wire/ibutton/ibutton_key.c
index 7b7571a29f..926a826a26 100644
--- a/lib/one_wire/ibutton/ibutton_key.c
+++ b/lib/one_wire/ibutton/ibutton_key.c
@@ -1,110 +1,43 @@
-#include <furi.h>
-#include <one_wire/maxim_crc.h>
-#include "ibutton_key.h"
+#include "ibutton_key_i.h"
 
 struct iButtonKey {
-    uint8_t data[IBUTTON_KEY_DATA_SIZE];
-    iButtonKeyType type;
+    iButtonProtocolId protocol_id;
+    iButtonProtocolData* protocol_data;
+    size_t protocol_data_size;
 };
 
-iButtonKey* ibutton_key_alloc() {
+iButtonKey* ibutton_key_alloc(size_t data_size) {
     iButtonKey* key = malloc(sizeof(iButtonKey));
-    memset(key, 0, sizeof(iButtonKey));
+
+    key->protocol_id = iButtonProtocolIdInvalid;
+    key->protocol_data = malloc(data_size);
+    key->protocol_data_size = data_size;
+
     return key;
 }
 
 void ibutton_key_free(iButtonKey* key) {
+    free(key->protocol_data);
     free(key);
 }
 
-void ibutton_key_set(iButtonKey* to, const iButtonKey* from) {
-    memcpy(to, from, sizeof(iButtonKey));
-}
-
-void ibutton_key_set_data(iButtonKey* key, uint8_t* data, uint8_t data_count) {
-    furi_check(data_count > 0);
-    furi_check(data_count <= IBUTTON_KEY_DATA_SIZE);
-
-    memset(key->data, 0, IBUTTON_KEY_DATA_SIZE);
-    memcpy(key->data, data, data_count);
-}
-
-void ibutton_key_clear_data(iButtonKey* key) {
-    memset(key->data, 0, IBUTTON_KEY_DATA_SIZE);
-}
-
-const uint8_t* ibutton_key_get_data_p(iButtonKey* key) {
-    return key->data;
-}
-
-uint8_t ibutton_key_get_data_size(iButtonKey* key) {
-    return ibutton_key_get_size_by_type(key->type);
+void ibutton_key_reset(iButtonKey* key) {
+    key->protocol_id = iButtonProtocolIdInvalid;
+    memset(key->protocol_data, 0, key->protocol_data_size);
 }
 
-void ibutton_key_set_type(iButtonKey* key, iButtonKeyType key_type) {
-    key->type = key_type;
-}
-
-iButtonKeyType ibutton_key_get_type(iButtonKey* key) {
-    return key->type;
-}
-
-const char* ibutton_key_get_string_by_type(iButtonKeyType key_type) {
-    switch(key_type) {
-    case iButtonKeyCyfral:
-        return "Cyfral";
-        break;
-    case iButtonKeyMetakom:
-        return "Metakom";
-        break;
-    case iButtonKeyDS1990:
-        return "Dallas";
-        break;
-    default:
-        furi_crash("Invalid iButton type");
-    }
-}
-
-bool ibutton_key_get_type_by_string(const char* type_string, iButtonKeyType* key_type) {
-    if(strcmp(type_string, ibutton_key_get_string_by_type(iButtonKeyCyfral)) == 0) {
-        *key_type = iButtonKeyCyfral;
-    } else if(strcmp(type_string, ibutton_key_get_string_by_type(iButtonKeyMetakom)) == 0) {
-        *key_type = iButtonKeyMetakom;
-    } else if(strcmp(type_string, ibutton_key_get_string_by_type(iButtonKeyDS1990)) == 0) {
-        *key_type = iButtonKeyDS1990;
-    } else {
-        return false;
-    }
-
-    return true;
-}
-
-uint8_t ibutton_key_get_size_by_type(iButtonKeyType key_type) {
-    uint8_t size = 0;
-
-    switch(key_type) {
-    case iButtonKeyCyfral:
-        size = 2;
-        break;
-    case iButtonKeyMetakom:
-        size = 4;
-        break;
-    case iButtonKeyDS1990:
-        size = 8;
-        break;
-    }
-
-    return size;
+iButtonProtocolId ibutton_key_get_protocol_id(const iButtonKey* key) {
+    return key->protocol_id;
 }
 
-uint8_t ibutton_key_get_max_size() {
-    return IBUTTON_KEY_DATA_SIZE;
+void ibutton_key_set_protocol_id(iButtonKey* key, iButtonProtocolId protocol_id) {
+    key->protocol_id = protocol_id;
 }
 
-bool ibutton_key_dallas_crc_is_valid(iButtonKey* key) {
-    return (maxim_crc8(key->data, 8, MAXIM_CRC8_INIT) == 0);
+iButtonProtocolData* ibutton_key_get_protocol_data(const iButtonKey* key) {
+    return key->protocol_data;
 }
 
-bool ibutton_key_dallas_is_1990_key(iButtonKey* key) {
-    return (key->data[0] == 0x01);
+size_t ibutton_key_get_protocol_data_size(const iButtonKey* key) {
+    return key->protocol_data_size;
 }
diff --git a/lib/one_wire/ibutton/ibutton_key.h b/lib/one_wire/ibutton/ibutton_key.h
index d682555a86..1848cd6721 100644
--- a/lib/one_wire/ibutton/ibutton_key.h
+++ b/lib/one_wire/ibutton/ibutton_key.h
@@ -5,127 +5,49 @@
  */
 
 #pragma once
-#include <stdint.h>
+
+#include <core/string.h>
+
+#include "protocols/protocol_common.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#define IBUTTON_KEY_DATA_SIZE 8
-#define IBUTTON_KEY_NAME_SIZE 22
-
-typedef enum {
-    iButtonKeyDS1990,
-    iButtonKeyCyfral,
-    iButtonKeyMetakom,
-} iButtonKeyType;
-
 typedef struct iButtonKey iButtonKey;
 
 /**
- * Allocate key
- * @return iButtonKey* 
+ * Allocate a key object
+ * @param [in] data_size maximum data size held by the key
+ * @return pointer to the key object
  */
-iButtonKey* ibutton_key_alloc();
+iButtonKey* ibutton_key_alloc(size_t data_size);
 
 /**
- * Free key
- * @param key 
+ * Destroy the key object, free resources
+ * @param [in] key pointer to the key object
  */
 void ibutton_key_free(iButtonKey* key);
 
 /**
- * Copy key
- * @param to 
- * @param from 
- */
-void ibutton_key_set(iButtonKey* to, const iButtonKey* from);
-
-/**
- * Set key data
- * @param key 
- * @param data 
- * @param data_count 
- */
-void ibutton_key_set_data(iButtonKey* key, uint8_t* data, uint8_t data_count);
-
-/**
- * Clear key data
- * @param key 
- */
-void ibutton_key_clear_data(iButtonKey* key);
-
-/**
- * Get pointer to key data
- * @param key 
- * @return const uint8_t* 
- */
-const uint8_t* ibutton_key_get_data_p(iButtonKey* key);
-
-/**
- * Get key data size
- * @param key 
- * @return uint8_t 
- */
-uint8_t ibutton_key_get_data_size(iButtonKey* key);
-
-/**
- * Set key type
- * @param key 
- * @param key_type 
- */
-void ibutton_key_set_type(iButtonKey* key, iButtonKeyType key_type);
-
-/**
- * Get key type
- * @param key 
- * @return iButtonKeyType 
- */
-iButtonKeyType ibutton_key_get_type(iButtonKey* key);
-
-/**
- * Get type string from key type
- * @param key_type 
- * @return const char* 
- */
-const char* ibutton_key_get_string_by_type(iButtonKeyType key_type);
-
-/**
- * Get key type from string
- * @param type_string 
- * @param key_type 
- * @return bool 
- */
-bool ibutton_key_get_type_by_string(const char* type_string, iButtonKeyType* key_type);
-
-/**
- * Get key data size from type
- * @param key_type 
- * @return uint8_t 
- */
-uint8_t ibutton_key_get_size_by_type(iButtonKeyType key_type);
-
-/**
- * Get max key size
- * @return uint8_t 
+ * Get the protocol id held by the key
+ * @param [in] key pointer to the key object
+ * @return protocol id held by the key
  */
-uint8_t ibutton_key_get_max_size();
+iButtonProtocolId ibutton_key_get_protocol_id(const iButtonKey* key);
 
 /**
- * Check if CRC for onewire key is valid
- * @param key 
- * @return true 
- * @return false 
+ * Set the protocol id held by the key
+ * @param [in] key pointer to the key object
+ * @param [in] protocol_id new protocol id
  */
-bool ibutton_key_dallas_crc_is_valid(iButtonKey* key);
+void ibutton_key_set_protocol_id(iButtonKey* key, iButtonProtocolId protocol_id);
 
 /**
- * Check if onewire key is a DS1990 key
- * @param key 
- * @return true 
- * @return false 
+ * Reset the protocol id and data held by the key
+ * @param [in] key pointer to the key object
  */
-bool ibutton_key_dallas_is_1990_key(iButtonKey* key);
+void ibutton_key_reset(iButtonKey* key);
 
 #ifdef __cplusplus
 }
diff --git a/lib/one_wire/ibutton/ibutton_key_command.h b/lib/one_wire/ibutton/ibutton_key_command.h
deleted file mode 100644
index 88049d0643..0000000000
--- a/lib/one_wire/ibutton/ibutton_key_command.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * @file ibutton_key_command.h
- * 
- * List of misc commands for Dallas and blanks
- */
-
-#pragma once
-
-#define RW1990_1_CMD_WRITE_RECORD_FLAG 0xD1
-#define RW1990_1_CMD_READ_RECORD_FLAG 0xB5
-#define RW1990_1_CMD_WRITE_ROM 0xD5
-
-#define RW1990_2_CMD_WRITE_RECORD_FLAG 0x1D
-#define RW1990_2_CMD_READ_RECORD_FLAG 0x1E
-#define RW1990_2_CMD_WRITE_ROM 0xD5
-
-#define TM2004_CMD_READ_STATUS 0xAA
-#define TM2004_CMD_READ_MEMORY 0xF0
-#define TM2004_CMD_WRITE_ROM 0x3C
-#define TM2004_CMD_FINALIZATION 0x35
-#define TM2004_ANSWER_READ_MEMORY 0xF5
-
-#define TM01_CMD_WRITE_RECORD_FLAG 0xC1
-#define TM01_CMD_WRITE_ROM 0xC5
-#define TM01_CMD_SWITCH_TO_CYFRAL 0xCA
-#define TM01_CMD_SWITCH_TO_METAKOM 0xCB
-
-#define DS1990_CMD_READ_ROM 0x33
diff --git a/lib/one_wire/ibutton/ibutton_key_i.h b/lib/one_wire/ibutton/ibutton_key_i.h
new file mode 100644
index 0000000000..b527c65b44
--- /dev/null
+++ b/lib/one_wire/ibutton/ibutton_key_i.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "ibutton_key.h"
+
+#include "protocols/protocol_common_i.h"
+
+iButtonProtocolData* ibutton_key_get_protocol_data(const iButtonKey* key);
+
+size_t ibutton_key_get_protocol_data_size(const iButtonKey* key);
diff --git a/lib/one_wire/ibutton/ibutton_protocols.c b/lib/one_wire/ibutton/ibutton_protocols.c
new file mode 100644
index 0000000000..75aa225efe
--- /dev/null
+++ b/lib/one_wire/ibutton/ibutton_protocols.c
@@ -0,0 +1,309 @@
+#include "ibutton_protocols.h"
+
+#include <storage/storage.h>
+
+#include "ibutton_key_i.h"
+
+#include "protocols/protocol_group_defs.h"
+
+#define IBUTTON_FILE_TYPE "Flipper iButton key"
+
+#define IBUTTON_PROTOCOL_KEY_V1 "Key type"
+#define IBUTTON_PROTOCOL_KEY_V2 "Protocol"
+
+#define IBUTTON_CURRENT_FORMAT_VERSION 2U
+
+#define GET_PROTOCOL_GROUP(id)     \
+    iButtonProtocolGroupInfo info; \
+    ibutton_protocols_get_group_by_id(protocols, (id), &info);
+
+#define GROUP_BASE (info.base)
+#define GROUP_DATA (info.group)
+#define PROTOCOL_ID (info.id)
+
+struct iButtonProtocols {
+    iButtonProtocolGroupData** group_datas;
+};
+
+typedef struct {
+    const iButtonProtocolGroupBase* base;
+    iButtonProtocolGroupData* group;
+    iButtonProtocolLocalId id;
+} iButtonProtocolGroupInfo;
+
+static void ibutton_protocols_get_group_by_id(
+    iButtonProtocols* protocols,
+    iButtonProtocolId id,
+    iButtonProtocolGroupInfo* info) {
+    iButtonProtocolLocalId local_id = id;
+
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        if(local_id < (signed)ibutton_protocol_groups[i]->protocol_count) {
+            info->base = ibutton_protocol_groups[i];
+            info->group = protocols->group_datas[i];
+            info->id = local_id;
+            return;
+
+        } else {
+            local_id -= ibutton_protocol_groups[i]->protocol_count;
+        }
+    }
+    furi_crash(NULL);
+}
+
+iButtonProtocols* ibutton_protocols_alloc() {
+    iButtonProtocols* protocols = malloc(sizeof(iButtonProtocols*));
+
+    protocols->group_datas = malloc(sizeof(iButtonProtocolGroupData*) * iButtonProtocolGroupMax);
+
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        protocols->group_datas[i] = ibutton_protocol_groups[i]->alloc();
+    }
+
+    return protocols;
+}
+
+void ibutton_protocols_free(iButtonProtocols* protocols) {
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        ibutton_protocol_groups[i]->free(protocols->group_datas[i]);
+    }
+
+    free(protocols->group_datas);
+    free(protocols);
+}
+
+uint32_t ibutton_protocols_get_protocol_count() {
+    uint32_t count = 0;
+
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        count += ibutton_protocol_groups[i]->protocol_count;
+    }
+
+    return count;
+}
+
+iButtonProtocolId ibutton_protocols_get_id_by_name(iButtonProtocols* protocols, const char* name) {
+    iButtonProtocolLocalId offset = 0;
+
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        iButtonProtocolLocalId local_id;
+        if(ibutton_protocol_groups[i]->get_id_by_name(protocols->group_datas[i], &local_id, name)) {
+            return local_id + offset;
+        }
+        offset += ibutton_protocol_groups[i]->protocol_count;
+    }
+    return iButtonProtocolIdInvalid;
+}
+
+uint32_t ibutton_protocols_get_features(iButtonProtocols* protocols, iButtonProtocolId id) {
+    GET_PROTOCOL_GROUP(id);
+    return GROUP_BASE->get_features(GROUP_DATA, PROTOCOL_ID);
+}
+
+size_t ibutton_protocols_get_max_data_size(iButtonProtocols* protocols) {
+    size_t max_size = 0;
+
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        const size_t current_max_size =
+            ibutton_protocol_groups[i]->get_max_data_size(protocols->group_datas[i]);
+        if(current_max_size > max_size) {
+            max_size = current_max_size;
+        }
+    }
+
+    return max_size;
+}
+
+const char* ibutton_protocols_get_manufacturer(iButtonProtocols* protocols, iButtonProtocolId id) {
+    GET_PROTOCOL_GROUP(id);
+    return GROUP_BASE->get_manufacturer(GROUP_DATA, PROTOCOL_ID);
+}
+
+const char* ibutton_protocols_get_name(iButtonProtocols* protocols, iButtonProtocolId id) {
+    GET_PROTOCOL_GROUP(id);
+    return GROUP_BASE->get_name(GROUP_DATA, PROTOCOL_ID);
+}
+
+bool ibutton_protocols_read(iButtonProtocols* protocols, iButtonKey* key) {
+    iButtonProtocolLocalId id = iButtonProtocolIdInvalid;
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    iButtonProtocolLocalId offset = 0;
+    for(iButtonProtocolGroupId i = 0; i < iButtonProtocolGroupMax; ++i) {
+        if(ibutton_protocol_groups[i]->read(protocols->group_datas[i], data, &id)) {
+            id += offset;
+            break;
+        }
+        offset += ibutton_protocol_groups[i]->protocol_count;
+    }
+
+    ibutton_key_set_protocol_id(key, id);
+    return id != iButtonProtocolIdInvalid;
+}
+
+bool ibutton_protocols_write_blank(iButtonProtocols* protocols, iButtonKey* key) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    return GROUP_BASE->write_blank(GROUP_DATA, data, PROTOCOL_ID);
+}
+
+bool ibutton_protocols_write_copy(iButtonProtocols* protocols, iButtonKey* key) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    return GROUP_BASE->write_copy(GROUP_DATA, data, PROTOCOL_ID);
+}
+
+void ibutton_protocols_emulate_start(iButtonProtocols* protocols, iButtonKey* key) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->emulate_start(GROUP_DATA, data, PROTOCOL_ID);
+}
+
+void ibutton_protocols_emulate_stop(iButtonProtocols* protocols, iButtonKey* key) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->emulate_stop(GROUP_DATA, data, PROTOCOL_ID);
+}
+
+bool ibutton_protocols_save(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    const char* file_name) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    bool success = false;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
+
+    do {
+        const char* protocol_name = ibutton_protocols_get_name(protocols, id);
+
+        if(!flipper_format_buffered_file_open_always(ff, file_name)) break;
+
+        if(!flipper_format_write_header_cstr(ff, IBUTTON_FILE_TYPE, IBUTTON_CURRENT_FORMAT_VERSION))
+            break;
+        if(!flipper_format_write_string_cstr(ff, IBUTTON_PROTOCOL_KEY_V2, protocol_name)) break;
+
+        GET_PROTOCOL_GROUP(id);
+        if(!GROUP_BASE->save(GROUP_DATA, data, PROTOCOL_ID, ff)) break;
+
+        success = true;
+    } while(false);
+
+    flipper_format_free(ff);
+    furi_record_close(RECORD_STORAGE);
+
+    return success;
+}
+
+bool ibutton_protocols_load(iButtonProtocols* protocols, iButtonKey* key, const char* file_name) {
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    bool success = false;
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
+    FuriString* tmp = furi_string_alloc();
+
+    do {
+        if(!flipper_format_buffered_file_open_existing(ff, file_name)) break;
+
+        uint32_t version;
+
+        if(!flipper_format_read_header(ff, tmp, &version)) break;
+        if(!furi_string_equal(tmp, IBUTTON_FILE_TYPE)) break;
+
+        if(version == 1) {
+            if(!flipper_format_read_string(ff, IBUTTON_PROTOCOL_KEY_V1, tmp)) break;
+        } else if(version == 2) {
+            if(!flipper_format_read_string(ff, IBUTTON_PROTOCOL_KEY_V2, tmp)) break;
+        } else {
+            break;
+        }
+
+        const iButtonProtocolId id =
+            ibutton_protocols_get_id_by_name(protocols, furi_string_get_cstr(tmp));
+        ibutton_key_set_protocol_id(key, id);
+
+        GET_PROTOCOL_GROUP(id);
+        if(!GROUP_BASE->load(GROUP_DATA, data, PROTOCOL_ID, version, ff)) break;
+
+        success = true;
+    } while(false);
+
+    flipper_format_free(ff);
+    furi_string_free(tmp);
+    furi_record_close(RECORD_STORAGE);
+
+    return success;
+}
+
+void ibutton_protocols_render_data(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    FuriString* result) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->render_data(GROUP_DATA, data, PROTOCOL_ID, result);
+}
+
+void ibutton_protocols_render_brief_data(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    FuriString* result) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->render_brief_data(GROUP_DATA, data, PROTOCOL_ID, result);
+}
+
+void ibutton_protocols_render_error(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    FuriString* result) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->render_error(GROUP_DATA, data, PROTOCOL_ID, result);
+}
+
+bool ibutton_protocols_is_valid(iButtonProtocols* protocols, const iButtonKey* key) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    const iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    return GROUP_BASE->is_valid(GROUP_DATA, data, PROTOCOL_ID);
+}
+
+void ibutton_protocols_get_editable_data(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    iButtonEditableData* editable) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->get_editable_data(GROUP_DATA, data, PROTOCOL_ID, editable);
+}
+
+void ibutton_protocols_apply_edits(iButtonProtocols* protocols, const iButtonKey* key) {
+    const iButtonProtocolId id = ibutton_key_get_protocol_id(key);
+    iButtonProtocolData* data = ibutton_key_get_protocol_data(key);
+
+    GET_PROTOCOL_GROUP(id);
+    GROUP_BASE->apply_edits(GROUP_DATA, data, PROTOCOL_ID);
+}
diff --git a/lib/one_wire/ibutton/ibutton_protocols.h b/lib/one_wire/ibutton/ibutton_protocols.h
new file mode 100644
index 0000000000..0e7ed0a804
--- /dev/null
+++ b/lib/one_wire/ibutton/ibutton_protocols.h
@@ -0,0 +1,197 @@
+/**
+ * @file ibutton_protocols.h
+ *
+ * Common interface for accessing various iButton protocols
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "protocols/protocol_common.h"
+
+#include "ibutton_key.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct iButtonProtocols iButtonProtocols;
+
+/**
+ * Allocate an iButtonProtocols object
+ * @return pointer to an iButtonProtocols object
+ */
+iButtonProtocols* ibutton_protocols_alloc();
+
+/**
+ * Destroy an iButtonProtocols object, free resources
+ * @param [in] protocols pointer to an iButtonProtocols object
+ */
+void ibutton_protocols_free(iButtonProtocols* protocols);
+
+/**
+ * Get the total number of available protocols
+ */
+uint32_t ibutton_protocols_get_protocol_count();
+
+/**
+ * Get maximum data size out of all protocols available
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @return maximum data size in bytes
+ */
+size_t ibutton_protocols_get_max_data_size(iButtonProtocols* protocols);
+
+/**
+ * Get the protocol id based on its name
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] name pointer to a string containing the name
+ * @return protocol id on success on iButtonProtocolIdInvalid on failure
+ */
+iButtonProtocolId ibutton_protocols_get_id_by_name(iButtonProtocols* protocols, const char* name);
+
+/**
+ * Get the manufacturer name based on the protocol id
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] id id of the protocol in question
+ * @return pointer to a statically allocated string with manufacturer name
+ */
+const char* ibutton_protocols_get_manufacturer(iButtonProtocols* protocols, iButtonProtocolId id);
+
+/**
+ * Get the protocol name based on the protocol id
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] id id of the protocol in question
+ * @return pointer to a statically allocated string with protocol name
+ */
+const char* ibutton_protocols_get_name(iButtonProtocols* protocols, iButtonProtocolId id);
+
+/**
+ * Get protocol features bitmask by protocol id
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] id id of the protocol in question
+ */
+uint32_t ibutton_protocols_get_features(iButtonProtocols* protocols, iButtonProtocolId id);
+
+/**
+ * Read a physical device (a key or an emulator)
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [out] key pointer to the key to read into (must be allocated before)
+ * @return true on success, false on failure
+ */
+bool ibutton_protocols_read(iButtonProtocols* protocols, iButtonKey* key);
+
+/**
+ * Write the key to a blank
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be written
+ * @return true on success, false on failure
+ */
+bool ibutton_protocols_write_blank(iButtonProtocols* protocols, iButtonKey* key);
+
+/**
+ * Write the key to another one of the same type
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be written
+ * @return true on success, false on failure
+ */
+bool ibutton_protocols_write_copy(iButtonProtocols* protocols, iButtonKey* key);
+
+/**
+ * Start emulating the key
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be emulated
+ */
+void ibutton_protocols_emulate_start(iButtonProtocols* protocols, iButtonKey* key);
+
+/**
+ * Stop emulating the key
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be emulated
+ */
+void ibutton_protocols_emulate_stop(iButtonProtocols* protocols, iButtonKey* key);
+
+/**
+ * Save the key data to a file.
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be saved
+ * @param [in] file_name full absolute path to the file name
+ * @return true on success, false on failure
+ */
+bool ibutton_protocols_save(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    const char* file_name);
+
+/**
+ * Load the key from a file.
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [out] key pointer to the key to load into (must be allocated before)
+ * @param [in] file_name full absolute path to the file name
+ * @return true on success, false on failure
+ */
+bool ibutton_protocols_load(iButtonProtocols* protocols, iButtonKey* key, const char* file_name);
+
+/**
+ * Format a string containing device full data
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be rendered
+ * @param [out] result pointer to the FuriString instance (must be initialized)
+ */
+void ibutton_protocols_render_data(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    FuriString* result);
+
+/**
+ * Format a string containing device brief data
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be rendered
+ * @param [out] result pointer to the FuriString instance (must be initialized)
+ */
+void ibutton_protocols_render_brief_data(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    FuriString* result);
+
+/**
+ * Format a string containing error message (for invalid keys)
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be rendered
+ * @param [out] result pointer to the FuriString instance (must be initialized)
+ */
+void ibutton_protocols_render_error(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    FuriString* result);
+
+/**
+ * Check whether the key data is valid
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be checked
+ * @return true if data is valid, false otherwise
+ */
+bool ibutton_protocols_is_valid(iButtonProtocols* protocols, const iButtonKey* key);
+
+/**
+ * Get a pointer to the key's editable data (for in-place editing)
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in] key pointer to the key to be checked
+ * @param [out] editable pointer to a structure to contain the editable data
+ */
+void ibutton_protocols_get_editable_data(
+    iButtonProtocols* protocols,
+    const iButtonKey* key,
+    iButtonEditableData* editable);
+
+/**
+ * Make all necessary internal adjustments after editing the key
+ * @param [in] protocols pointer to an iButtonProtocols object
+ * @param [in,out] key pointer to the key to be adjusted
+ */
+void ibutton_protocols_apply_edits(iButtonProtocols* protocols, const iButtonKey* key);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/one_wire/ibutton/ibutton_worker.c b/lib/one_wire/ibutton/ibutton_worker.c
index 1fe39b5e5e..d40dba71ae 100644
--- a/lib/one_wire/ibutton/ibutton_worker.c
+++ b/lib/one_wire/ibutton/ibutton_worker.c
@@ -1,13 +1,14 @@
-#include <furi.h>
-#include <furi_hal.h>
-#include <atomic.h>
 #include "ibutton_worker_i.h"
+#include "ibutton_protocols.h"
+
+#include <core/check.h>
 
 typedef enum {
     iButtonMessageEnd,
     iButtonMessageStop,
     iButtonMessageRead,
-    iButtonMessageWrite,
+    iButtonMessageWriteBlank,
+    iButtonMessageWriteCopy,
     iButtonMessageEmulate,
     iButtonMessageNotifyEmulate,
 } iButtonMessageType;
@@ -21,26 +22,15 @@ typedef struct {
 
 static int32_t ibutton_worker_thread(void* thread_context);
 
-iButtonWorker* ibutton_worker_alloc() {
+iButtonWorker* ibutton_worker_alloc(iButtonProtocols* protocols) {
     iButtonWorker* worker = malloc(sizeof(iButtonWorker));
-    worker->key_p = NULL;
-    worker->key_data = malloc(ibutton_key_get_max_size());
-    worker->host = onewire_host_alloc(&ibutton_gpio);
-    worker->slave = onewire_slave_alloc(&ibutton_gpio);
-    worker->writer = ibutton_writer_alloc(worker->host);
-    worker->device = onewire_device_alloc(0, 0, 0, 0, 0, 0, 0, 0);
-    worker->messages = furi_message_queue_alloc(1, sizeof(iButtonMessage));
 
-    worker->mode_index = iButtonWorkerIdle;
-    worker->read_cb = NULL;
-    worker->write_cb = NULL;
-    worker->emulate_cb = NULL;
-    worker->cb_ctx = NULL;
+    worker->protocols = protocols;
+    worker->messages = furi_message_queue_alloc(1, sizeof(iButtonMessage));
 
+    worker->mode_index = iButtonWorkerModeIdle;
     worker->thread = furi_thread_alloc_ex("iButtonWorker", 2048, ibutton_worker_thread, worker);
 
-    worker->protocols = protocol_dict_alloc(ibutton_protocols, iButtonProtocolMax);
-
     return worker;
 }
 
@@ -48,7 +38,7 @@ void ibutton_worker_read_set_callback(
     iButtonWorker* worker,
     iButtonWorkerReadCallback callback,
     void* context) {
-    furi_check(worker->mode_index == iButtonWorkerIdle);
+    furi_check(worker->mode_index == iButtonWorkerModeIdle);
     worker->read_cb = callback;
     worker->cb_ctx = context;
 }
@@ -57,7 +47,7 @@ void ibutton_worker_write_set_callback(
     iButtonWorker* worker,
     iButtonWorkerWriteCallback callback,
     void* context) {
-    furi_check(worker->mode_index == iButtonWorkerIdle);
+    furi_check(worker->mode_index == iButtonWorkerModeIdle);
     worker->write_cb = callback;
     worker->cb_ctx = context;
 }
@@ -66,7 +56,7 @@ void ibutton_worker_emulate_set_callback(
     iButtonWorker* worker,
     iButtonWorkerEmulateCallback callback,
     void* context) {
-    furi_check(worker->mode_index == iButtonWorkerIdle);
+    furi_check(worker->mode_index == iButtonWorkerModeIdle);
     worker->emulate_cb = callback;
     worker->cb_ctx = context;
 }
@@ -77,8 +67,14 @@ void ibutton_worker_read_start(iButtonWorker* worker, iButtonKey* key) {
         furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
 }
 
-void ibutton_worker_write_start(iButtonWorker* worker, iButtonKey* key) {
-    iButtonMessage message = {.type = iButtonMessageWrite, .data.key = key};
+void ibutton_worker_write_blank_start(iButtonWorker* worker, iButtonKey* key) {
+    iButtonMessage message = {.type = iButtonMessageWriteBlank, .data.key = key};
+    furi_check(
+        furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
+}
+
+void ibutton_worker_write_copy_start(iButtonWorker* worker, iButtonKey* key) {
+    iButtonMessage message = {.type = iButtonMessageWriteCopy, .data.key = key};
     furi_check(
         furi_message_queue_put(worker->messages, &message, FuriWaitForever) == FuriStatusOk);
 }
@@ -96,19 +92,8 @@ void ibutton_worker_stop(iButtonWorker* worker) {
 }
 
 void ibutton_worker_free(iButtonWorker* worker) {
-    ibutton_writer_free(worker->writer);
-
-    onewire_slave_free(worker->slave);
-
-    onewire_host_free(worker->host);
-    onewire_device_free(worker->device);
-
-    protocol_dict_free(worker->protocols);
-
     furi_message_queue_free(worker->messages);
-
     furi_thread_free(worker->thread);
-    free(worker->key_data);
     free(worker);
 }
 
@@ -137,7 +122,7 @@ void ibutton_worker_notify_emulate(iButtonWorker* worker) {
 }
 
 void ibutton_worker_set_key_p(iButtonWorker* worker, iButtonKey* key) {
-    worker->key_p = key;
+    worker->key = key;
 }
 
 static int32_t ibutton_worker_thread(void* thread_context) {
@@ -154,25 +139,29 @@ static int32_t ibutton_worker_thread(void* thread_context) {
         if(status == FuriStatusOk) {
             switch(message.type) {
             case iButtonMessageEnd:
-                ibutton_worker_switch_mode(worker, iButtonWorkerIdle);
+                ibutton_worker_switch_mode(worker, iButtonWorkerModeIdle);
                 ibutton_worker_set_key_p(worker, NULL);
                 running = false;
                 break;
             case iButtonMessageStop:
-                ibutton_worker_switch_mode(worker, iButtonWorkerIdle);
+                ibutton_worker_switch_mode(worker, iButtonWorkerModeIdle);
                 ibutton_worker_set_key_p(worker, NULL);
                 break;
             case iButtonMessageRead:
                 ibutton_worker_set_key_p(worker, message.data.key);
-                ibutton_worker_switch_mode(worker, iButtonWorkerRead);
+                ibutton_worker_switch_mode(worker, iButtonWorkerModeRead);
+                break;
+            case iButtonMessageWriteBlank:
+                ibutton_worker_set_key_p(worker, message.data.key);
+                ibutton_worker_switch_mode(worker, iButtonWorkerModeWriteBlank);
                 break;
-            case iButtonMessageWrite:
+            case iButtonMessageWriteCopy:
                 ibutton_worker_set_key_p(worker, message.data.key);
-                ibutton_worker_switch_mode(worker, iButtonWorkerWrite);
+                ibutton_worker_switch_mode(worker, iButtonWorkerModeWriteCopy);
                 break;
             case iButtonMessageEmulate:
                 ibutton_worker_set_key_p(worker, message.data.key);
-                ibutton_worker_switch_mode(worker, iButtonWorkerEmulate);
+                ibutton_worker_switch_mode(worker, iButtonWorkerModeEmulate);
                 break;
             case iButtonMessageNotifyEmulate:
                 if(worker->emulate_cb) {
diff --git a/lib/one_wire/ibutton/ibutton_worker.h b/lib/one_wire/ibutton/ibutton_worker.h
index 5c8b1fc399..2a12a3194d 100644
--- a/lib/one_wire/ibutton/ibutton_worker.h
+++ b/lib/one_wire/ibutton/ibutton_worker.h
@@ -5,7 +5,9 @@
  */
 
 #pragma once
+
 #include "ibutton_key.h"
+#include "ibutton_protocols.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -28,7 +30,7 @@ typedef struct iButtonWorker iButtonWorker;
  * Allocate ibutton worker
  * @return iButtonWorker* 
  */
-iButtonWorker* ibutton_worker_alloc();
+iButtonWorker* ibutton_worker_alloc(iButtonProtocols* protocols);
 
 /**
  * Free ibutton worker
@@ -78,11 +80,18 @@ void ibutton_worker_write_set_callback(
     void* context);
 
 /**
- * Start write mode
+ * Start write blank mode
  * @param worker 
  * @param key 
  */
-void ibutton_worker_write_start(iButtonWorker* worker, iButtonKey* key);
+void ibutton_worker_write_blank_start(iButtonWorker* worker, iButtonKey* key);
+
+/**
+ * Start write copy mode
+ * @param worker
+ * @param key
+ */
+void ibutton_worker_write_copy_start(iButtonWorker* worker, iButtonKey* key);
 
 /**
  * Set "emulate success" callback
diff --git a/lib/one_wire/ibutton/ibutton_worker_i.h b/lib/one_wire/ibutton/ibutton_worker_i.h
index 2396fbd61c..5f259a38af 100644
--- a/lib/one_wire/ibutton/ibutton_worker_i.h
+++ b/lib/one_wire/ibutton/ibutton_worker_i.h
@@ -5,13 +5,11 @@
  */
 
 #pragma once
+
+#include <core/thread.h>
+#include <core/message_queue.h>
+
 #include "ibutton_worker.h"
-#include "ibutton_writer.h"
-#include "../one_wire_host.h"
-#include "../one_wire_slave.h"
-#include "../one_wire_device.h"
-#include <toolbox/protocols/protocol_dict.h>
-#include "protocols/ibutton_protocols.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -25,19 +23,16 @@ typedef struct {
 } iButtonWorkerModeType;
 
 typedef enum {
-    iButtonWorkerIdle = 0,
-    iButtonWorkerRead = 1,
-    iButtonWorkerWrite = 2,
-    iButtonWorkerEmulate = 3,
+    iButtonWorkerModeIdle,
+    iButtonWorkerModeRead,
+    iButtonWorkerModeWriteBlank,
+    iButtonWorkerModeWriteCopy,
+    iButtonWorkerModeEmulate,
 } iButtonWorkerMode;
 
 struct iButtonWorker {
-    iButtonKey* key_p;
-    uint8_t* key_data;
-    OneWireHost* host;
-    OneWireSlave* slave;
-    OneWireDevice* device;
-    iButtonWriter* writer;
+    iButtonKey* key;
+    iButtonProtocols* protocols;
     iButtonWorkerMode mode_index;
     FuriMessageQueue* messages;
     FuriThread* thread;
@@ -45,10 +40,8 @@ struct iButtonWorker {
     iButtonWorkerReadCallback read_cb;
     iButtonWorkerWriteCallback write_cb;
     iButtonWorkerEmulateCallback emulate_cb;
-    void* cb_ctx;
 
-    ProtocolDict* protocols;
-    iButtonProtocol protocol_to_encode;
+    void* cb_ctx;
 };
 
 extern const iButtonWorkerModeType ibutton_worker_modes[];
diff --git a/lib/one_wire/ibutton/ibutton_worker_modes.c b/lib/one_wire/ibutton/ibutton_worker_modes.c
index 4f7f0855ab..1b8e0a3b89 100644
--- a/lib/one_wire/ibutton/ibutton_worker_modes.c
+++ b/lib/one_wire/ibutton/ibutton_worker_modes.c
@@ -1,23 +1,28 @@
-#include <furi.h>
-#include <furi_hal.h>
 #include "ibutton_worker_i.h"
-#include "ibutton_key_command.h"
 
-void ibutton_worker_mode_idle_start(iButtonWorker* worker);
-void ibutton_worker_mode_idle_tick(iButtonWorker* worker);
-void ibutton_worker_mode_idle_stop(iButtonWorker* worker);
+#include <core/check.h>
 
-void ibutton_worker_mode_emulate_start(iButtonWorker* worker);
-void ibutton_worker_mode_emulate_tick(iButtonWorker* worker);
-void ibutton_worker_mode_emulate_stop(iButtonWorker* worker);
+#include <furi_hal_rfid.h>
+#include <furi_hal_power.h>
 
-void ibutton_worker_mode_read_start(iButtonWorker* worker);
-void ibutton_worker_mode_read_tick(iButtonWorker* worker);
-void ibutton_worker_mode_read_stop(iButtonWorker* worker);
+#include "ibutton_protocols.h"
 
-void ibutton_worker_mode_write_start(iButtonWorker* worker);
-void ibutton_worker_mode_write_tick(iButtonWorker* worker);
-void ibutton_worker_mode_write_stop(iButtonWorker* worker);
+static void ibutton_worker_mode_idle_start(iButtonWorker* worker);
+static void ibutton_worker_mode_idle_tick(iButtonWorker* worker);
+static void ibutton_worker_mode_idle_stop(iButtonWorker* worker);
+
+static void ibutton_worker_mode_emulate_start(iButtonWorker* worker);
+static void ibutton_worker_mode_emulate_tick(iButtonWorker* worker);
+static void ibutton_worker_mode_emulate_stop(iButtonWorker* worker);
+
+static void ibutton_worker_mode_read_start(iButtonWorker* worker);
+static void ibutton_worker_mode_read_tick(iButtonWorker* worker);
+static void ibutton_worker_mode_read_stop(iButtonWorker* worker);
+
+static void ibutton_worker_mode_write_common_start(iButtonWorker* worker);
+static void ibutton_worker_mode_write_blank_tick(iButtonWorker* worker);
+static void ibutton_worker_mode_write_copy_tick(iButtonWorker* worker);
+static void ibutton_worker_mode_write_common_stop(iButtonWorker* worker);
 
 const iButtonWorkerModeType ibutton_worker_modes[] = {
     {
@@ -34,9 +39,15 @@ const iButtonWorkerModeType ibutton_worker_modes[] = {
     },
     {
         .quant = 1000,
-        .start = ibutton_worker_mode_write_start,
-        .tick = ibutton_worker_mode_write_tick,
-        .stop = ibutton_worker_mode_write_stop,
+        .start = ibutton_worker_mode_write_common_start,
+        .tick = ibutton_worker_mode_write_blank_tick,
+        .stop = ibutton_worker_mode_write_common_stop,
+    },
+    {
+        .quant = 1000,
+        .start = ibutton_worker_mode_write_common_start,
+        .tick = ibutton_worker_mode_write_copy_tick,
+        .stop = ibutton_worker_mode_write_common_stop,
     },
     {
         .quant = 1000,
@@ -62,143 +73,18 @@ void ibutton_worker_mode_idle_stop(iButtonWorker* worker) {
 
 /*********************** READ ***********************/
 
-typedef struct {
-    uint32_t last_dwt_value;
-    FuriStreamBuffer* stream;
-} iButtonReadContext;
-
-void ibutton_worker_comparator_callback(bool level, void* context) {
-    iButtonReadContext* read_context = context;
-
-    uint32_t current_dwt_value = DWT->CYCCNT;
-
-    LevelDuration data =
-        level_duration_make(level, current_dwt_value - read_context->last_dwt_value);
-    furi_stream_buffer_send(read_context->stream, &data, sizeof(LevelDuration), 0);
-
-    read_context->last_dwt_value = current_dwt_value;
-}
-
-bool ibutton_worker_read_comparator(iButtonWorker* worker) {
-    bool result = false;
-
-    protocol_dict_decoders_start(worker->protocols);
-
-    furi_hal_rfid_pins_reset();
-    // pulldown pull pin, we sense the signal through the analog part of the RFID schematic
-    furi_hal_rfid_pin_pull_pulldown();
-
-    iButtonReadContext read_context = {
-        .last_dwt_value = DWT->CYCCNT,
-        .stream = furi_stream_buffer_alloc(sizeof(LevelDuration) * 512, 1),
-    };
-
-    furi_hal_rfid_comp_set_callback(ibutton_worker_comparator_callback, &read_context);
-    furi_hal_rfid_comp_start();
-
-    uint32_t tick_start = furi_get_tick();
-    while(true) {
-        LevelDuration level;
-        size_t ret =
-            furi_stream_buffer_receive(read_context.stream, &level, sizeof(LevelDuration), 100);
-
-        if((furi_get_tick() - tick_start) > 100) {
-            break;
-        }
-
-        if(ret > 0) {
-            ProtocolId decoded_index = protocol_dict_decoders_feed(
-                worker->protocols,
-                level_duration_get_level(level),
-                level_duration_get_duration(level));
-
-            if(decoded_index == PROTOCOL_NO) continue;
-
-            protocol_dict_get_data(
-                worker->protocols, decoded_index, worker->key_data, ibutton_key_get_max_size());
-
-            switch(decoded_index) {
-            case iButtonProtocolCyfral:
-                furi_check(worker->key_p != NULL);
-                ibutton_key_set_type(worker->key_p, iButtonKeyCyfral);
-                ibutton_key_set_data(worker->key_p, worker->key_data, ibutton_key_get_max_size());
-                result = true;
-                break;
-            case iButtonProtocolMetakom:
-                furi_check(worker->key_p != NULL);
-                ibutton_key_set_type(worker->key_p, iButtonKeyMetakom);
-                ibutton_key_set_data(worker->key_p, worker->key_data, ibutton_key_get_max_size());
-                result = true;
-                break;
-            default:
-                break;
-            }
-        }
-    }
-
-    furi_hal_rfid_comp_stop();
-    furi_hal_rfid_comp_set_callback(NULL, NULL);
-    furi_hal_rfid_pins_reset();
-
-    furi_stream_buffer_free(read_context.stream);
-
-    return result;
-}
-
-bool ibutton_worker_read_dallas(iButtonWorker* worker) {
-    bool result = false;
-    onewire_host_start(worker->host);
-    furi_delay_ms(100);
-    FURI_CRITICAL_ENTER();
-    if(onewire_host_search(worker->host, worker->key_data, NORMAL_SEARCH)) {
-        onewire_host_reset_search(worker->host);
-
-        // key found, verify
-        if(onewire_host_reset(worker->host)) {
-            onewire_host_write(worker->host, DS1990_CMD_READ_ROM);
-            bool key_valid = true;
-            for(uint8_t i = 0; i < ibutton_key_get_max_size(); i++) {
-                if(onewire_host_read(worker->host) != worker->key_data[i]) {
-                    key_valid = false;
-                    break;
-                }
-            }
-
-            if(key_valid) {
-                result = true;
-
-                furi_check(worker->key_p != NULL);
-                ibutton_key_set_type(worker->key_p, iButtonKeyDS1990);
-                ibutton_key_set_data(worker->key_p, worker->key_data, ibutton_key_get_max_size());
-            }
-        }
-    } else {
-        onewire_host_reset_search(worker->host);
-    }
-    onewire_host_stop(worker->host);
-    FURI_CRITICAL_EXIT();
-    return result;
-}
-
 void ibutton_worker_mode_read_start(iButtonWorker* worker) {
     UNUSED(worker);
     furi_hal_power_enable_otg();
 }
 
 void ibutton_worker_mode_read_tick(iButtonWorker* worker) {
-    bool valid = false;
-    if(ibutton_worker_read_dallas(worker)) {
-        valid = true;
-    } else if(ibutton_worker_read_comparator(worker)) {
-        valid = true;
-    }
-
-    if(valid) {
+    if(ibutton_protocols_read(worker->protocols, worker->key)) {
         if(worker->read_cb != NULL) {
             worker->read_cb(worker->cb_ctx);
         }
 
-        ibutton_worker_switch_mode(worker, iButtonWorkerIdle);
+        ibutton_worker_switch_mode(worker, iButtonWorkerModeIdle);
     }
 }
 
@@ -208,83 +94,14 @@ void ibutton_worker_mode_read_stop(iButtonWorker* worker) {
 }
 
 /*********************** EMULATE ***********************/
-static void onewire_slave_callback(void* context) {
-    furi_assert(context);
-    iButtonWorker* worker = context;
-    ibutton_worker_notify_emulate(worker);
-}
-
-void ibutton_worker_emulate_dallas_start(iButtonWorker* worker) {
-    uint8_t* device_id = onewire_device_get_id_p(worker->device);
-    const uint8_t* key_id = ibutton_key_get_data_p(worker->key_p);
-    const uint8_t key_size = ibutton_key_get_max_size();
-    memcpy(device_id, key_id, key_size);
-
-    onewire_slave_attach(worker->slave, worker->device);
-    onewire_slave_set_result_callback(worker->slave, onewire_slave_callback, worker);
-    onewire_slave_start(worker->slave);
-}
-
-void ibutton_worker_emulate_dallas_stop(iButtonWorker* worker) {
-    onewire_slave_stop(worker->slave);
-    onewire_slave_detach(worker->slave);
-}
-
-void ibutton_worker_emulate_timer_cb(void* context) {
-    furi_assert(context);
-    iButtonWorker* worker = context;
-
-    const LevelDuration level_duration =
-        protocol_dict_encoder_yield(worker->protocols, worker->protocol_to_encode);
-
-    furi_hal_ibutton_emulate_set_next(level_duration_get_duration(level_duration));
-    furi_hal_ibutton_pin_write(level_duration_get_level(level_duration));
-}
-
-void ibutton_worker_emulate_timer_start(iButtonWorker* worker) {
-    furi_assert(worker->key_p);
-    const uint8_t* key_id = ibutton_key_get_data_p(worker->key_p);
-    const uint8_t key_size = ibutton_key_get_max_size();
-
-    switch(ibutton_key_get_type(worker->key_p)) {
-    case iButtonKeyDS1990:
-        return;
-        break;
-    case iButtonKeyCyfral:
-        worker->protocol_to_encode = iButtonProtocolCyfral;
-        break;
-    case iButtonKeyMetakom:
-        worker->protocol_to_encode = iButtonProtocolMetakom;
-        break;
-    }
-
-    protocol_dict_set_data(worker->protocols, worker->protocol_to_encode, key_id, key_size);
-    protocol_dict_encoder_start(worker->protocols, worker->protocol_to_encode);
-
-    furi_hal_ibutton_pin_configure();
-    furi_hal_ibutton_emulate_start(0, ibutton_worker_emulate_timer_cb, worker);
-}
-
-void ibutton_worker_emulate_timer_stop(iButtonWorker* worker) {
-    UNUSED(worker);
-    furi_hal_ibutton_emulate_stop();
-}
 
 void ibutton_worker_mode_emulate_start(iButtonWorker* worker) {
-    furi_assert(worker->key_p);
+    furi_assert(worker->key);
 
     furi_hal_rfid_pins_reset();
     furi_hal_rfid_pin_pull_pulldown();
 
-    switch(ibutton_key_get_type(worker->key_p)) {
-    case iButtonKeyDS1990:
-        ibutton_worker_emulate_dallas_start(worker);
-        break;
-    case iButtonKeyCyfral:
-    case iButtonKeyMetakom:
-        ibutton_worker_emulate_timer_start(worker);
-        break;
-    }
+    ibutton_protocols_emulate_start(worker->protocols, worker->key);
 }
 
 void ibutton_worker_mode_emulate_tick(iButtonWorker* worker) {
@@ -292,56 +109,45 @@ void ibutton_worker_mode_emulate_tick(iButtonWorker* worker) {
 }
 
 void ibutton_worker_mode_emulate_stop(iButtonWorker* worker) {
-    furi_assert(worker->key_p);
+    furi_assert(worker->key);
 
-    furi_hal_rfid_pins_reset();
+    ibutton_protocols_emulate_stop(worker->protocols, worker->key);
 
-    switch(ibutton_key_get_type(worker->key_p)) {
-    case iButtonKeyDS1990:
-        ibutton_worker_emulate_dallas_stop(worker);
-        break;
-    case iButtonKeyCyfral:
-    case iButtonKeyMetakom:
-        ibutton_worker_emulate_timer_stop(worker);
-        break;
-    }
+    furi_hal_rfid_pins_reset();
 }
 
 /*********************** WRITE ***********************/
 
-void ibutton_worker_mode_write_start(iButtonWorker* worker) {
+void ibutton_worker_mode_write_common_start(iButtonWorker* worker) { //-V524
+    UNUSED(worker);
     furi_hal_power_enable_otg();
-    onewire_host_start(worker->host);
 }
 
-void ibutton_worker_mode_write_tick(iButtonWorker* worker) {
-    furi_check(worker->key_p != NULL);
-    iButtonWriterResult writer_result = ibutton_writer_write(worker->writer, worker->key_p);
-    iButtonWorkerWriteResult result;
-    switch(writer_result) {
-    case iButtonWriterOK:
-        result = iButtonWorkerWriteOK;
-        break;
-    case iButtonWriterSameKey:
-        result = iButtonWorkerWriteSameKey;
-        break;
-    case iButtonWriterNoDetect:
-        result = iButtonWorkerWriteNoDetect;
-        break;
-    case iButtonWriterCannotWrite:
-        result = iButtonWorkerWriteCannotWrite;
-        break;
-    default:
-        result = iButtonWorkerWriteNoDetect;
-        break;
+void ibutton_worker_mode_write_blank_tick(iButtonWorker* worker) {
+    furi_assert(worker->key);
+
+    const bool success = ibutton_protocols_write_blank(worker->protocols, worker->key);
+    // TODO: pass a proper result to the callback
+    const iButtonWorkerWriteResult result = success ? iButtonWorkerWriteOK :
+                                                      iButtonWorkerWriteNoDetect;
+    if(worker->write_cb != NULL) {
+        worker->write_cb(worker->cb_ctx, result);
     }
+}
 
+void ibutton_worker_mode_write_copy_tick(iButtonWorker* worker) {
+    furi_assert(worker->key);
+
+    const bool success = ibutton_protocols_write_copy(worker->protocols, worker->key);
+    // TODO: pass a proper result to the callback
+    const iButtonWorkerWriteResult result = success ? iButtonWorkerWriteOK :
+                                                      iButtonWorkerWriteNoDetect;
     if(worker->write_cb != NULL) {
         worker->write_cb(worker->cb_ctx, result);
     }
 }
 
-void ibutton_worker_mode_write_stop(iButtonWorker* worker) {
+void ibutton_worker_mode_write_common_stop(iButtonWorker* worker) { //-V524
+    UNUSED(worker);
     furi_hal_power_disable_otg();
-    onewire_host_stop(worker->host);
 }
diff --git a/lib/one_wire/ibutton/ibutton_writer.c b/lib/one_wire/ibutton/ibutton_writer.c
deleted file mode 100644
index 84d122491a..0000000000
--- a/lib/one_wire/ibutton/ibutton_writer.c
+++ /dev/null
@@ -1,298 +0,0 @@
-#include <furi.h>
-#include <furi_hal.h>
-#include "ibutton_writer.h"
-#include "ibutton_key_command.h"
-
-/*********************** PRIVATE ***********************/
-
-struct iButtonWriter {
-    OneWireHost* host;
-};
-
-static void writer_write_one_bit(iButtonWriter* writer, bool value, uint32_t delay) {
-    onewire_host_write_bit(writer->host, value);
-    furi_delay_us(delay);
-}
-
-static void writer_write_byte_ds1990(iButtonWriter* writer, uint8_t data) {
-    for(uint8_t n_bit = 0; n_bit < 8; n_bit++) {
-        onewire_host_write_bit(writer->host, data & 1);
-        furi_delay_us(5000);
-        data = data >> 1;
-    }
-}
-
-static bool writer_compare_key_ds1990(iButtonWriter* writer, iButtonKey* key) {
-    bool result = false;
-
-    if(ibutton_key_get_type(key) == iButtonKeyDS1990) {
-        FURI_CRITICAL_ENTER();
-        bool presence = onewire_host_reset(writer->host);
-
-        if(presence) {
-            onewire_host_write(writer->host, DS1990_CMD_READ_ROM);
-
-            result = true;
-            for(uint8_t i = 0; i < ibutton_key_get_data_size(key); i++) {
-                if(ibutton_key_get_data_p(key)[i] != onewire_host_read(writer->host)) {
-                    result = false;
-                    break;
-                }
-            }
-        }
-
-        FURI_CRITICAL_EXIT();
-    }
-
-    return result;
-}
-
-static bool writer_write_TM2004(iButtonWriter* writer, iButtonKey* key) {
-    uint8_t answer;
-    bool result = true;
-
-    if(ibutton_key_get_type(key) == iButtonKeyDS1990) {
-        FURI_CRITICAL_ENTER();
-
-        // write rom, addr is 0x0000
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, TM2004_CMD_WRITE_ROM);
-        onewire_host_write(writer->host, 0x00);
-        onewire_host_write(writer->host, 0x00);
-
-        // write key
-        for(uint8_t i = 0; i < ibutton_key_get_data_size(key); i++) {
-            // write key byte
-            onewire_host_write(writer->host, ibutton_key_get_data_p(key)[i]);
-            answer = onewire_host_read(writer->host);
-            // TODO: check answer CRC
-
-            // pulse indicating that data is correct
-            furi_delay_us(600);
-            writer_write_one_bit(writer, 1, 50000);
-
-            // read written key byte
-            answer = onewire_host_read(writer->host); //-V519
-
-            // check that written and read are same
-            if(ibutton_key_get_data_p(key)[i] != answer) {
-                result = false;
-                break;
-            }
-        }
-
-        if(!writer_compare_key_ds1990(writer, key)) {
-            result = false;
-        }
-
-        onewire_host_reset(writer->host);
-
-        FURI_CRITICAL_EXIT();
-    } else {
-        result = false;
-    }
-
-    return result;
-}
-
-static bool writer_write_1990_1(iButtonWriter* writer, iButtonKey* key) {
-    bool result = false;
-
-    if(ibutton_key_get_type(key) == iButtonKeyDS1990) {
-        FURI_CRITICAL_ENTER();
-
-        // unlock
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, RW1990_1_CMD_WRITE_RECORD_FLAG);
-        furi_delay_us(10);
-        writer_write_one_bit(writer, 0, 5000);
-
-        // write key
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, RW1990_1_CMD_WRITE_ROM);
-        for(uint8_t i = 0; i < ibutton_key_get_data_size(key); i++) {
-            // inverted key for RW1990.1
-            writer_write_byte_ds1990(writer, ~ibutton_key_get_data_p(key)[i]);
-            furi_delay_us(30000);
-        }
-
-        // lock
-        onewire_host_write(writer->host, RW1990_1_CMD_WRITE_RECORD_FLAG);
-        writer_write_one_bit(writer, 1, 10000);
-
-        FURI_CRITICAL_EXIT();
-
-        if(writer_compare_key_ds1990(writer, key)) {
-            result = true;
-        }
-    }
-
-    return result;
-}
-
-static bool writer_write_1990_2(iButtonWriter* writer, iButtonKey* key) {
-    bool result = false;
-
-    if(ibutton_key_get_type(key) == iButtonKeyDS1990) {
-        FURI_CRITICAL_ENTER();
-
-        // unlock
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, RW1990_2_CMD_WRITE_RECORD_FLAG);
-        furi_delay_us(10);
-        writer_write_one_bit(writer, 1, 5000);
-
-        // write key
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, RW1990_2_CMD_WRITE_ROM);
-        for(uint8_t i = 0; i < ibutton_key_get_data_size(key); i++) {
-            writer_write_byte_ds1990(writer, ibutton_key_get_data_p(key)[i]);
-            furi_delay_us(30000);
-        }
-
-        // lock
-        onewire_host_write(writer->host, RW1990_2_CMD_WRITE_RECORD_FLAG);
-        writer_write_one_bit(writer, 0, 10000);
-
-        FURI_CRITICAL_EXIT();
-
-        if(writer_compare_key_ds1990(writer, key)) {
-            result = true;
-        }
-    }
-
-    return result;
-}
-
-/*
-// TODO: adapt and test
-static bool writer_write_TM01(
-    iButtonWriter* writer,
-    iButtonKey type,
-    const uint8_t* key,
-    uint8_t key_length) {
-    bool result = true;
-
-    {
-        // TODO test and encoding
-        FURI_CRITICAL_ENTER();
-
-        // unlock
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, TM01::CMD_WRITE_RECORD_FLAG);
-        onewire_write_one_bit(1, 10000);
-
-        // write key
-        onewire_host_reset(writer->host);
-        onewire_host_write(writer->host, TM01::CMD_WRITE_ROM);
-
-        // TODO: key types
-        //if(type == KEY_METAKOM || type == KEY_CYFRAL) {
-        //} else {
-        for(uint8_t i = 0; i < key->get_type_data_size(); i++) {
-            write_byte_ds1990(key->get_data()[i]);
-            furi_delay_us(10000);
-        }
-        //}
-
-        // lock
-        onewire_host_write(writer->host, TM01::CMD_WRITE_RECORD_FLAG);
-        onewire_write_one_bit(0, 10000);
-
-        FURI_CRITICAL_EXIT();
-    }
-
-    if(!compare_key_ds1990(key)) {
-        result = false;
-    }
-
-    {
-        FURI_CRITICAL_ENTER();
-
-        if(key->get_key_type() == iButtonKeyType::KeyMetakom ||
-           key->get_key_type() == iButtonKeyType::KeyCyfral) {
-            onewire_host_reset(writer->host);
-            if(key->get_key_type() == iButtonKeyType::KeyCyfral)
-                onewire_host_write(writer->host, TM01::CMD_SWITCH_TO_CYFRAL);
-            else
-                onewire_host_write(writer->host, TM01::CMD_SWITCH_TO_METAKOM);
-            onewire_write_one_bit(1);
-        }
-
-        FURI_CRITICAL_EXIT();
-    }
-
-    return result;
-}
-*/
-
-static iButtonWriterResult writer_write_DS1990(iButtonWriter* writer, iButtonKey* key) {
-    iButtonWriterResult result = iButtonWriterNoDetect;
-    bool same_key = writer_compare_key_ds1990(writer, key);
-
-    if(!same_key) {
-        // currently we can write:
-        // RW1990_1, TM08v2, TM08vi-2 by write_1990_1()
-        // RW1990_2 by write_1990_2()
-        // RW2004, RW2004, TM2004 with EEPROM by write_TM2004();
-
-        bool write_result = true;
-        do {
-            if(writer_write_1990_1(writer, key)) break;
-            if(writer_write_1990_2(writer, key)) break;
-            if(writer_write_TM2004(writer, key)) break;
-            write_result = false;
-        } while(false);
-
-        if(write_result) {
-            result = iButtonWriterOK;
-        } else {
-            result = iButtonWriterCannotWrite;
-        }
-    } else {
-        result = iButtonWriterSameKey;
-    }
-
-    return result;
-}
-
-/*********************** PUBLIC ***********************/
-
-iButtonWriter* ibutton_writer_alloc(OneWireHost* host) {
-    iButtonWriter* writer = malloc(sizeof(iButtonWriter));
-    writer->host = host;
-    return writer;
-}
-
-void ibutton_writer_free(iButtonWriter* writer) {
-    free(writer);
-}
-
-iButtonWriterResult ibutton_writer_write(iButtonWriter* writer, iButtonKey* key) {
-    iButtonWriterResult result = iButtonWriterNoDetect;
-
-    furi_kernel_lock();
-    bool blank_present = onewire_host_reset(writer->host);
-    furi_kernel_unlock();
-
-    if(blank_present) {
-        switch(ibutton_key_get_type(key)) {
-        case iButtonKeyDS1990:
-            result = writer_write_DS1990(writer, key);
-        default:
-            break;
-        }
-    }
-
-    return result;
-}
-
-void ibutton_writer_start(iButtonWriter* writer) {
-    furi_hal_power_enable_otg();
-    onewire_host_start(writer->host);
-}
-
-void ibutton_writer_stop(iButtonWriter* writer) {
-    onewire_host_stop(writer->host);
-    furi_hal_power_disable_otg();
-}
diff --git a/lib/one_wire/ibutton/ibutton_writer.h b/lib/one_wire/ibutton/ibutton_writer.h
deleted file mode 100644
index 6dbdbb27a1..0000000000
--- a/lib/one_wire/ibutton/ibutton_writer.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * @file ibutton_writer.h
- * 
- * iButton blanks writer
- */
-
-#pragma once
-#include <furi_hal_gpio.h>
-#include "ibutton_key.h"
-#include "../one_wire_host.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    iButtonWriterOK,
-    iButtonWriterSameKey,
-    iButtonWriterNoDetect,
-    iButtonWriterCannotWrite,
-} iButtonWriterResult;
-
-typedef struct iButtonWriter iButtonWriter;
-
-/**
- * Allocate writer
- * @param host 
- * @return iButtonWriter* 
- */
-iButtonWriter* ibutton_writer_alloc(OneWireHost* host);
-
-/**
- * Deallocate writer
- * @param writer 
- */
-void ibutton_writer_free(iButtonWriter* writer);
-
-/**
- * Write key to blank
- * @param writer 
- * @param key 
- * @return iButtonWriterResult 
- */
-iButtonWriterResult ibutton_writer_write(iButtonWriter* writer, iButtonKey* key);
-
-/**
- * Start writing. Must be called before write attempt
- * @param writer 
- */
-void ibutton_writer_start(iButtonWriter* writer);
-
-/**
- * Stop writing
- * @param writer 
- */
-void ibutton_writer_stop(iButtonWriter* writer);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/lib/one_wire/ibutton/protocols/blanks/rw1990.c b/lib/one_wire/ibutton/protocols/blanks/rw1990.c
new file mode 100644
index 0000000000..d3350fcf00
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/blanks/rw1990.c
@@ -0,0 +1,95 @@
+#include "rw1990.h"
+
+#include <core/kernel.h>
+
+#define RW1990_1_CMD_WRITE_RECORD_FLAG 0xD1
+#define RW1990_1_CMD_READ_RECORD_FLAG 0xB5
+#define RW1990_1_CMD_WRITE_ROM 0xD5
+
+#define RW1990_2_CMD_WRITE_RECORD_FLAG 0x1D
+#define RW1990_2_CMD_READ_RECORD_FLAG 0x1E
+#define RW1990_2_CMD_WRITE_ROM 0xD5
+
+#define DS1990_CMD_READ_ROM 0x33
+
+static void rw1990_write_byte(OneWireHost* host, uint8_t value) {
+    for(uint8_t bitMask = 0x01; bitMask; bitMask <<= 1) {
+        onewire_host_write_bit(host, (bool)(bitMask & value));
+        furi_delay_us(5000);
+    }
+}
+
+static bool rw1990_read_and_compare(OneWireHost* host, const uint8_t* data, size_t data_size) {
+    bool success = false;
+
+    if(onewire_host_reset(host)) {
+        success = true;
+        onewire_host_write(host, DS1990_CMD_READ_ROM);
+
+        for(size_t i = 0; i < data_size; ++i) {
+            if(data[i] != onewire_host_read(host)) {
+                success = false;
+                break;
+            }
+        }
+    }
+
+    return success;
+}
+
+bool rw1990_write_v1(OneWireHost* host, const uint8_t* data, size_t data_size) {
+    // Unlock sequence
+    onewire_host_reset(host);
+    onewire_host_write(host, RW1990_1_CMD_WRITE_RECORD_FLAG);
+    furi_delay_us(10);
+
+    onewire_host_write_bit(host, false);
+    furi_delay_us(5000);
+
+    // Write data
+    onewire_host_reset(host);
+    onewire_host_write(host, RW1990_1_CMD_WRITE_ROM);
+
+    for(size_t i = 0; i < data_size; ++i) {
+        // inverted key for RW1990.1
+        rw1990_write_byte(host, ~(data[i]));
+        furi_delay_us(30000);
+    }
+
+    // Lock sequence
+    onewire_host_write(host, RW1990_1_CMD_WRITE_RECORD_FLAG);
+
+    onewire_host_write_bit(host, true);
+    furi_delay_us(10000);
+
+    // TODO: Better error handling
+    return rw1990_read_and_compare(host, data, data_size);
+}
+
+bool rw1990_write_v2(OneWireHost* host, const uint8_t* data, size_t data_size) {
+    // Unlock sequence
+    onewire_host_reset(host);
+    onewire_host_write(host, RW1990_2_CMD_WRITE_RECORD_FLAG);
+    furi_delay_us(10);
+
+    onewire_host_write_bit(host, true);
+    furi_delay_us(5000);
+
+    // Write data
+    onewire_host_reset(host);
+    onewire_host_write(host, RW1990_2_CMD_WRITE_ROM);
+
+    for(size_t i = 0; i < data_size; ++i) {
+        rw1990_write_byte(host, data[i]);
+        furi_delay_us(30000);
+    }
+
+    // Lock sequence
+    onewire_host_write(host, RW1990_2_CMD_WRITE_RECORD_FLAG);
+
+    onewire_host_write_bit(host, false);
+    furi_delay_us(10000);
+
+    // TODO: Better error handling
+    return rw1990_read_and_compare(host, data, data_size);
+}
diff --git a/lib/one_wire/ibutton/protocols/blanks/rw1990.h b/lib/one_wire/ibutton/protocols/blanks/rw1990.h
new file mode 100644
index 0000000000..bdd27f6bfb
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/blanks/rw1990.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <stddef.h>
+
+#include <one_wire/one_wire_host.h>
+
+bool rw1990_write_v1(OneWireHost* host, const uint8_t* data, size_t data_size);
+
+bool rw1990_write_v2(OneWireHost* host, const uint8_t* data, size_t data_size);
diff --git a/lib/one_wire/ibutton/protocols/blanks/tm2004.c b/lib/one_wire/ibutton/protocols/blanks/tm2004.c
new file mode 100644
index 0000000000..ef6f0619e1
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/blanks/tm2004.c
@@ -0,0 +1,42 @@
+#include "tm2004.h"
+
+#include <core/kernel.h>
+
+#define TM2004_CMD_READ_STATUS 0xAA
+#define TM2004_CMD_READ_MEMORY 0xF0
+#define TM2004_CMD_WRITE_ROM 0x3C
+#define TM2004_CMD_FINALIZATION 0x35
+#define TM2004_ANSWER_READ_MEMORY 0xF5
+
+bool tm2004_write(OneWireHost* host, const uint8_t* data, size_t data_size) {
+    onewire_host_reset(host);
+    onewire_host_write(host, TM2004_CMD_WRITE_ROM);
+    // Starting writing from address 0x0000
+    onewire_host_write(host, 0x00);
+    onewire_host_write(host, 0x00);
+
+    size_t i;
+    for(i = 0; i < data_size; ++i) {
+        uint8_t answer;
+
+        onewire_host_write(host, data[i]);
+        answer = onewire_host_read(host);
+        // TODO: check answer CRC
+
+        // pulse indicating that data is correct
+        furi_delay_us(600);
+        onewire_host_write_bit(host, true);
+        furi_delay_us(50000);
+
+        // read written key byte
+        answer = onewire_host_read(host); //-V519
+
+        // check that written and read are same
+        if(data[i] != answer) {
+            break;
+        }
+    }
+
+    // TODO: Better error handling
+    return i == data_size;
+}
diff --git a/lib/one_wire/ibutton/protocols/blanks/tm2004.h b/lib/one_wire/ibutton/protocols/blanks/tm2004.h
new file mode 100644
index 0000000000..15713af565
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/blanks/tm2004.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <stddef.h>
+
+#include <one_wire/one_wire_host.h>
+
+bool tm2004_write(OneWireHost* host, const uint8_t* data, size_t data_size);
diff --git a/lib/one_wire/ibutton/protocols/dallas/dallas_common.c b/lib/one_wire/ibutton/protocols/dallas/dallas_common.c
new file mode 100644
index 0000000000..57a873b1d1
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/dallas_common.c
@@ -0,0 +1,250 @@
+#include "dallas_common.h"
+
+#include <core/common_defines.h>
+#include <one_wire/maxim_crc.h>
+
+#define BITS_IN_BYTE 8U
+
+#define DALLAS_COMMON_ROM_DATA_KEY_V1 "Data"
+#define DALLAS_COMMON_ROM_DATA_KEY_V2 "Rom Data"
+
+#define DALLAS_COMMON_COPY_SCRATCH_MIN_TIMEOUT_US 5U
+#define DALLAS_COMMON_COPY_SCRATCH_POLL_COUNT 20U
+
+#define DALLAS_COMMON_END_ADDRESS_MASK 0x01F
+#define DALLAS_COMMON_STATUS_FLAG_PF (1U << 5)
+#define DALLAS_COMMON_STATUS_FLAG_OF (1U << 6)
+#define DALLAS_COMMON_STATUS_FLAG_AA (1U << 7)
+
+#define DALLAS_COMMON_BRIEF_HEAD_COUNT 4U
+#define DALLAS_COMMON_BRIEF_TAIL_COUNT 3U
+
+#define BITS_IN_BYTE 8U
+#define BITS_IN_KBIT 1024U
+
+bool dallas_common_skip_rom(OneWireHost* host) {
+    onewire_host_write(host, DALLAS_COMMON_CMD_SKIP_ROM);
+    return true;
+}
+
+bool dallas_common_read_rom(OneWireHost* host, DallasCommonRomData* rom_data) {
+    onewire_host_write(host, DALLAS_COMMON_CMD_READ_ROM);
+    onewire_host_read_bytes(host, rom_data->bytes, sizeof(DallasCommonRomData));
+
+    return dallas_common_is_valid_crc(rom_data);
+}
+
+bool dallas_common_write_scratchpad(
+    OneWireHost* host,
+    uint16_t address,
+    const uint8_t* data,
+    size_t data_size) {
+    onewire_host_write(host, DALLAS_COMMON_CMD_WRITE_SCRATCH);
+    onewire_host_write(host, (uint8_t)address);
+    onewire_host_write(host, (uint8_t)(address >> BITS_IN_BYTE));
+
+    onewire_host_write_bytes(host, data, data_size);
+
+    return true;
+}
+
+bool dallas_common_read_scratchpad(
+    OneWireHost* host,
+    DallasCommonAddressRegs* regs,
+    uint8_t* data,
+    size_t data_size) {
+    onewire_host_write(host, DALLAS_COMMON_CMD_READ_SCRATCH);
+    onewire_host_read_bytes(host, regs->bytes, sizeof(DallasCommonAddressRegs));
+    onewire_host_read_bytes(host, data, data_size);
+
+    return true;
+}
+
+bool dallas_common_copy_scratchpad(
+    OneWireHost* host,
+    const DallasCommonAddressRegs* regs,
+    uint32_t timeout_us) {
+    onewire_host_write(host, DALLAS_COMMON_CMD_COPY_SCRATCH);
+    onewire_host_write_bytes(host, regs->bytes, sizeof(DallasCommonAddressRegs));
+
+    const uint32_t poll_delay =
+        MAX(timeout_us / DALLAS_COMMON_COPY_SCRATCH_POLL_COUNT,
+            DALLAS_COMMON_COPY_SCRATCH_MIN_TIMEOUT_US);
+
+    uint32_t time_elapsed;
+    for(time_elapsed = 0; time_elapsed < timeout_us; time_elapsed += poll_delay) {
+        if(!onewire_host_read_bit(host)) break;
+        furi_delay_us(poll_delay);
+    }
+
+    return time_elapsed < timeout_us;
+}
+
+bool dallas_common_read_mem(OneWireHost* host, uint16_t address, uint8_t* data, size_t data_size) {
+    onewire_host_write(host, DALLAS_COMMON_CMD_READ_MEM);
+
+    onewire_host_write(host, (uint8_t)address);
+    onewire_host_write(host, (uint8_t)(address > BITS_IN_BYTE));
+
+    onewire_host_read_bytes(host, data, (uint16_t)data_size);
+
+    return true;
+}
+
+bool dallas_common_write_mem(
+    OneWireHost* host,
+    uint32_t timeout_us,
+    size_t page_size,
+    const uint8_t* data,
+    size_t data_size) {
+    // Data size must be a multiple of page size
+    furi_check(data_size % page_size == 0);
+
+    DallasCommonAddressRegs regs;
+    uint8_t* scratch = malloc(page_size);
+
+    size_t i;
+    for(i = 0; i < data_size; i += page_size) {
+        const uint8_t* data_ptr = data + i;
+
+        // Write scratchpad with the next page value
+        if(!onewire_host_reset(host)) break;
+        if(!dallas_common_skip_rom(host)) break;
+        if(!dallas_common_write_scratchpad(host, i, data_ptr, page_size)) break;
+
+        // Read back the scratchpad contents and address registers
+        if(!onewire_host_reset(host)) break;
+        if(!dallas_common_skip_rom(host)) break;
+        if(!dallas_common_read_scratchpad(host, &regs, scratch, page_size)) break;
+
+        // Verify scratchpad contents
+        if(memcmp(data_ptr, scratch, page_size) != 0) break;
+
+        // Write scratchpad to internal memory
+        if(!onewire_host_reset(host)) break;
+        if(!dallas_common_skip_rom(host)) break;
+        if(!dallas_common_copy_scratchpad(host, &regs, timeout_us)) break;
+
+        // Read back the address registers again
+        if(!onewire_host_reset(host)) break;
+        if(!dallas_common_skip_rom(host)) break;
+        if(!dallas_common_read_scratchpad(host, &regs, scratch, 0)) break;
+
+        // Check if AA flag is set
+        if(!(regs.fields.status & DALLAS_COMMON_STATUS_FLAG_AA)) break;
+    }
+
+    free(scratch);
+
+    return i == data_size;
+}
+
+bool dallas_common_emulate_search_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data) {
+    for(size_t i = 0; i < sizeof(DallasCommonRomData); i++) {
+        for(size_t j = 0; j < BITS_IN_BYTE; j++) {
+            bool bit = (rom_data->bytes[i] >> j) & 0x01;
+
+            if(!onewire_slave_send_bit(bus, bit)) return false;
+            if(!onewire_slave_send_bit(bus, !bit)) return false;
+
+            onewire_slave_receive_bit(bus);
+            // TODO: check for errors and return if any
+        }
+    }
+
+    return true;
+}
+
+bool dallas_common_emulate_read_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data) {
+    return onewire_slave_send(bus, rom_data->bytes, sizeof(DallasCommonRomData));
+}
+
+bool dallas_common_emulate_read_mem(OneWireSlave* bus, const uint8_t* data, size_t data_size) {
+    bool success = false;
+
+    union {
+        uint8_t bytes[sizeof(uint16_t)];
+        uint16_t word;
+    } address;
+
+    do {
+        if(!onewire_slave_receive(bus, address.bytes, sizeof(address))) break;
+        if(address.word >= data_size) break;
+        if(!onewire_slave_send(bus, data + address.word, data_size - address.word)) break;
+
+        success = true;
+    } while(false);
+
+    return success;
+}
+
+bool dallas_common_save_rom_data(FlipperFormat* ff, const DallasCommonRomData* rom_data) {
+    return flipper_format_write_hex(
+        ff, DALLAS_COMMON_ROM_DATA_KEY_V2, rom_data->bytes, sizeof(DallasCommonRomData));
+}
+
+bool dallas_common_load_rom_data(
+    FlipperFormat* ff,
+    uint32_t format_version,
+    DallasCommonRomData* rom_data) {
+    switch(format_version) {
+    case 1:
+        return flipper_format_read_hex(
+            ff, DALLAS_COMMON_ROM_DATA_KEY_V1, rom_data->bytes, sizeof(DallasCommonRomData));
+    case 2:
+        return flipper_format_read_hex(
+            ff, DALLAS_COMMON_ROM_DATA_KEY_V2, rom_data->bytes, sizeof(DallasCommonRomData));
+    default:
+        return false;
+    }
+}
+
+bool dallas_common_is_valid_crc(const DallasCommonRomData* rom_data) {
+    const uint8_t crc_calculated =
+        maxim_crc8(rom_data->bytes, sizeof(DallasCommonRomData) - 1, MAXIM_CRC8_INIT);
+    const uint8_t crc_received = rom_data->fields.checksum;
+
+    return crc_calculated == crc_received;
+}
+
+void dallas_common_render_brief_data(
+    FuriString* result,
+    const DallasCommonRomData* rom_data,
+    const uint8_t* sram_data,
+    size_t sram_data_size) {
+    for(size_t i = 0; i < sizeof(rom_data->bytes); ++i) {
+        furi_string_cat_printf(result, "%02X ", rom_data->bytes[i]);
+    }
+
+    furi_string_cat_printf(
+        result,
+        "\nInternal SRAM: %zu Kbit\n",
+        (size_t)(sram_data_size * BITS_IN_BYTE / BITS_IN_KBIT));
+
+    for(size_t i = 0; i < DALLAS_COMMON_BRIEF_HEAD_COUNT; ++i) {
+        furi_string_cat_printf(result, "%02X ", sram_data[i]);
+    }
+
+    furi_string_cat_printf(result, "[  . . .  ]");
+
+    for(size_t i = sram_data_size - DALLAS_COMMON_BRIEF_TAIL_COUNT; i < sram_data_size; ++i) {
+        furi_string_cat_printf(result, " %02X", sram_data[i]);
+    }
+}
+
+void dallas_common_render_crc_error(FuriString* result, const DallasCommonRomData* rom_data) {
+    furi_string_set(result, "CRC Error\n");
+
+    const size_t data_size = sizeof(DallasCommonRomData);
+
+    for(size_t i = 0; i < data_size; ++i) {
+        furi_string_cat_printf(result, (i < data_size - 1) ? "%02X " : "%02X", rom_data->bytes[i]);
+    }
+}
+
+void dallas_common_apply_edits(DallasCommonRomData* rom_data, uint8_t family_code) {
+    rom_data->fields.family_code = family_code;
+    const uint8_t crc =
+        maxim_crc8(rom_data->bytes, sizeof(DallasCommonRomData) - 1, MAXIM_CRC8_INIT);
+    rom_data->fields.checksum = crc;
+}
diff --git a/lib/one_wire/ibutton/protocols/dallas/dallas_common.h b/lib/one_wire/ibutton/protocols/dallas/dallas_common.h
new file mode 100644
index 0000000000..7ad13eb2cb
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/dallas_common.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <flipper_format.h>
+
+#include <one_wire/one_wire_host.h>
+#include <one_wire/one_wire_slave.h>
+
+#define DALLAS_COMMON_MANUFACTURER_NAME "Dallas"
+
+#define DALLAS_COMMON_CMD_READ_ROM 0x33U
+#define DALLAS_COMMON_CMD_MATCH_ROM 0x55U
+#define DALLAS_COMMON_CMD_SKIP_ROM 0xCCU
+#define DALLAS_COMMON_CMD_COND_SEARCH 0xECU
+#define DALLAS_COMMON_CMD_SEARCH_ROM 0xF0U
+
+#define DALLAS_COMMON_CMD_READ_SCRATCH 0xAAU
+#define DALLAS_COMMON_CMD_WRITE_SCRATCH 0x0FU
+#define DALLAS_COMMON_CMD_COPY_SCRATCH 0x55U
+
+#define DALLAS_COMMON_CMD_READ_MEM 0xF0U
+
+#define DALLAS_COMMON_CMD_OVERDRIVE_SKIP_ROM 0x3CU
+#define DALLAS_COMMON_CMD_OVERDRIVE_MATCH_ROM 0x69U
+
+typedef enum {
+    DallasCommonCommandStateIdle,
+    DallasCommonCommandStateRomCmd,
+    DallasCommonCommandStateMemCmd,
+} DallasCommonCommandState;
+
+typedef union {
+    struct {
+        uint8_t family_code;
+        uint8_t serial_number[6];
+        uint8_t checksum;
+    } fields;
+    uint8_t bytes[8];
+} DallasCommonRomData;
+
+typedef union {
+    struct {
+        uint8_t address_lo;
+        uint8_t address_hi;
+        uint8_t status;
+    } fields;
+    uint8_t bytes[3];
+} DallasCommonAddressRegs;
+
+/* Standard(ish) iButton commands */
+bool dallas_common_skip_rom(OneWireHost* host);
+
+bool dallas_common_read_rom(OneWireHost* host, DallasCommonRomData* rom_data);
+
+bool dallas_common_write_scratchpad(
+    OneWireHost* host,
+    uint16_t address,
+    const uint8_t* data,
+    size_t data_size);
+
+bool dallas_common_read_scratchpad(
+    OneWireHost* host,
+    DallasCommonAddressRegs* regs,
+    uint8_t* data,
+    size_t data_size);
+
+bool dallas_common_copy_scratchpad(
+    OneWireHost* host,
+    const DallasCommonAddressRegs* regs,
+    uint32_t timeout_us);
+
+bool dallas_common_read_mem(OneWireHost* host, uint16_t address, uint8_t* data, size_t data_size);
+
+/* Combined operations */
+bool dallas_common_write_mem(
+    OneWireHost* host,
+    uint32_t timeout_us,
+    size_t page_size,
+    const uint8_t* data,
+    size_t data_size);
+
+/* Emulation */
+bool dallas_common_emulate_search_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data);
+
+bool dallas_common_emulate_read_rom(OneWireSlave* bus, const DallasCommonRomData* rom_data);
+
+bool dallas_common_emulate_read_mem(OneWireSlave* bus, const uint8_t* data, size_t data_size);
+
+/* Save & Load */
+bool dallas_common_save_rom_data(FlipperFormat* ff, const DallasCommonRomData* rom_data);
+
+bool dallas_common_load_rom_data(
+    FlipperFormat* ff,
+    uint32_t format_version,
+    DallasCommonRomData* rom_data);
+
+/* Miscellaneous */
+bool dallas_common_is_valid_crc(const DallasCommonRomData* rom_data);
+
+void dallas_common_render_brief_data(
+    FuriString* result,
+    const DallasCommonRomData* rom_data,
+    const uint8_t* sram_data,
+    size_t sram_data_size);
+
+void dallas_common_render_crc_error(FuriString* result, const DallasCommonRomData* rom_data);
+
+void dallas_common_apply_edits(DallasCommonRomData* rom_data, uint8_t family_code);
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_dallas_base.h b/lib/one_wire/ibutton/protocols/dallas/protocol_dallas_base.h
new file mode 100644
index 0000000000..b4edb2b20d
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_dallas_base.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "../protocol_common_i.h"
+
+#include <flipper_format.h>
+
+#include <one_wire/one_wire_host.h>
+#include <one_wire/one_wire_slave.h>
+
+typedef bool (*iButtonProtocolDallasReadWriteFunc)(OneWireHost*, iButtonProtocolData*);
+typedef void (*iButtonProtocolDallasEmulateFunc)(OneWireSlave*, iButtonProtocolData*);
+typedef bool (*iButtonProtocolDallasSaveFunc)(FlipperFormat*, const iButtonProtocolData*);
+typedef bool (*iButtonProtocolDallasLoadFunc)(FlipperFormat*, uint32_t, iButtonProtocolData*);
+typedef void (*iButtonProtocolDallasRenderDataFunc)(FuriString*, const iButtonProtocolData*);
+typedef bool (*iButtonProtocolDallasIsValidFunc)(const iButtonProtocolData*);
+typedef void (
+    *iButtonProtocolDallasGetEditableDataFunc)(iButtonEditableData*, iButtonProtocolData*);
+typedef void (*iButtonProtocolDallasApplyEditsFunc)(iButtonProtocolData*);
+
+typedef struct {
+    const uint8_t family_code;
+    const uint32_t features;
+    const size_t data_size;
+    const char* manufacturer;
+    const char* name;
+
+    iButtonProtocolDallasReadWriteFunc read;
+    iButtonProtocolDallasReadWriteFunc write_blank;
+    iButtonProtocolDallasReadWriteFunc write_copy;
+    iButtonProtocolDallasEmulateFunc emulate;
+    iButtonProtocolDallasSaveFunc save;
+    iButtonProtocolDallasLoadFunc load;
+    iButtonProtocolDallasRenderDataFunc render_data;
+    iButtonProtocolDallasRenderDataFunc render_brief_data;
+    iButtonProtocolDallasRenderDataFunc render_error;
+    iButtonProtocolDallasIsValidFunc is_valid;
+    iButtonProtocolDallasGetEditableDataFunc get_editable_data;
+    iButtonProtocolDallasApplyEditsFunc apply_edits;
+} iButtonProtocolDallasBase;
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.c b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.c
new file mode 100644
index 0000000000..0d9c937ee4
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.c
@@ -0,0 +1,144 @@
+#include "protocol_ds1990.h"
+
+#include <core/string.h>
+#include <core/core_defines.h>
+
+#include "dallas_common.h"
+
+#include "../blanks/rw1990.h"
+#include "../blanks/tm2004.h"
+
+#define DS1990_FAMILY_CODE 0x01U
+#define DS1990_FAMILY_NAME "DS1990"
+
+#define DS1990_CMD_READ_ROM 0x0FU
+
+typedef struct {
+    OneWireSlave* bus;
+} DS1990ProtocolState;
+
+typedef struct {
+    DallasCommonRomData rom_data;
+    DS1990ProtocolState state;
+} DS1990ProtocolData;
+
+static bool dallas_ds1990_read(OneWireHost*, iButtonProtocolData*);
+static bool dallas_ds1990_write_blank(OneWireHost*, iButtonProtocolData*);
+static void dallas_ds1990_emulate(OneWireSlave*, iButtonProtocolData*);
+static bool dallas_ds1990_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
+static bool dallas_ds1990_save(FlipperFormat*, const iButtonProtocolData*);
+static void dallas_ds1990_render_brief_data(FuriString*, const iButtonProtocolData*);
+static void dallas_ds1990_render_error(FuriString*, const iButtonProtocolData*);
+static bool dallas_ds1990_is_data_valid(const iButtonProtocolData*);
+static void dallas_ds1990_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
+static void dallas_ds1990_apply_edits(iButtonProtocolData*);
+
+const iButtonProtocolDallasBase ibutton_protocol_ds1990 = {
+    .family_code = DS1990_FAMILY_CODE,
+    .features = iButtonProtocolFeatureWriteBlank,
+    .data_size = sizeof(DS1990ProtocolData),
+    .manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
+    .name = DS1990_FAMILY_NAME,
+
+    .read = dallas_ds1990_read,
+    .write_blank = dallas_ds1990_write_blank,
+    .write_copy = NULL, /* No data to write a copy */
+    .emulate = dallas_ds1990_emulate,
+    .save = dallas_ds1990_save,
+    .load = dallas_ds1990_load,
+    .render_data = NULL, /* No data to render */
+    .render_brief_data = dallas_ds1990_render_brief_data,
+    .render_error = dallas_ds1990_render_error,
+    .is_valid = dallas_ds1990_is_data_valid,
+    .get_editable_data = dallas_ds1990_get_editable_data,
+    .apply_edits = dallas_ds1990_apply_edits,
+};
+
+bool dallas_ds1990_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1990ProtocolData* data = protocol_data;
+    return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data);
+}
+
+bool dallas_ds1990_write_blank(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1990ProtocolData* data = protocol_data;
+
+    return rw1990_write_v1(host, data->rom_data.bytes, sizeof(DallasCommonRomData)) ||
+           rw1990_write_v2(host, data->rom_data.bytes, sizeof(DallasCommonRomData)) ||
+           tm2004_write(host, data->rom_data.bytes, sizeof(DallasCommonRomData));
+}
+
+static bool dallas_ds1990_command_callback(uint8_t command, void* context) {
+    furi_assert(context);
+    DS1990ProtocolData* data = context;
+    OneWireSlave* bus = data->state.bus;
+
+    switch(command) {
+    case DALLAS_COMMON_CMD_SEARCH_ROM:
+        dallas_common_emulate_search_rom(bus, &data->rom_data);
+        break;
+    case DALLAS_COMMON_CMD_READ_ROM:
+    case DS1990_CMD_READ_ROM:
+        dallas_common_emulate_read_rom(bus, &data->rom_data);
+        break;
+    default:
+        break;
+    }
+
+    // No support for multiple consecutive commands
+    return false;
+}
+
+void dallas_ds1990_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
+    DS1990ProtocolData* data = protocol_data;
+    data->state.bus = bus;
+
+    onewire_slave_set_reset_callback(bus, NULL, NULL);
+    onewire_slave_set_command_callback(bus, dallas_ds1990_command_callback, protocol_data);
+}
+
+bool dallas_ds1990_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
+    const DS1990ProtocolData* data = protocol_data;
+    return dallas_common_save_rom_data(ff, &data->rom_data);
+}
+
+bool dallas_ds1990_load(
+    FlipperFormat* ff,
+    uint32_t format_version,
+    iButtonProtocolData* protocol_data) {
+    DS1990ProtocolData* data = protocol_data;
+    return dallas_common_load_rom_data(ff, format_version, &data->rom_data);
+}
+
+void dallas_ds1990_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1990ProtocolData* data = protocol_data;
+
+    for(size_t i = 0; i < sizeof(DallasCommonRomData); ++i) {
+        furi_string_cat_printf(result, "%02X ", data->rom_data.bytes[i]);
+    }
+}
+
+void dallas_ds1990_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1990ProtocolData* data = protocol_data;
+
+    if(!dallas_common_is_valid_crc(&data->rom_data)) {
+        dallas_common_render_crc_error(result, &data->rom_data);
+    }
+}
+
+bool dallas_ds1990_is_data_valid(const iButtonProtocolData* protocol_data) {
+    const DS1990ProtocolData* data = protocol_data;
+    return dallas_common_is_valid_crc(&data->rom_data);
+}
+
+void dallas_ds1990_get_editable_data(
+    iButtonEditableData* editable_data,
+    iButtonProtocolData* protocol_data) {
+    DS1990ProtocolData* data = protocol_data;
+    editable_data->ptr = data->rom_data.bytes;
+    editable_data->size = sizeof(DallasCommonRomData);
+}
+
+void dallas_ds1990_apply_edits(iButtonProtocolData* protocol_data) {
+    DS1990ProtocolData* data = protocol_data;
+    dallas_common_apply_edits(&data->rom_data, DS1990_FAMILY_CODE);
+}
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.h b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.h
new file mode 100644
index 0000000000..de3da0e4cb
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1990.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "protocol_dallas_base.h"
+
+extern const iButtonProtocolDallasBase ibutton_protocol_ds1990;
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.c b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.c
new file mode 100644
index 0000000000..131bc634a0
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.c
@@ -0,0 +1,218 @@
+#include "protocol_ds1992.h"
+
+#include <core/core_defines.h>
+#include <toolbox/pretty_format.h>
+
+#include "dallas_common.h"
+
+#include "../blanks/tm2004.h"
+
+#define DS1992_FAMILY_CODE 0x08U
+#define DS1992_FAMILY_NAME "DS1992"
+
+#define DS1992_SRAM_DATA_SIZE 128U
+#define DS1992_SRAM_PAGE_SIZE 4U
+#define DS1992_COPY_SCRATCH_TIMEOUT_US 100U
+
+#define DS1992_DATA_BYTE_COUNT 4U
+
+#define DS1992_SRAM_DATA_KEY "Sram Data"
+
+typedef struct {
+    OneWireSlave* bus;
+    DallasCommonCommandState command_state;
+} DS1992ProtocolState;
+
+typedef struct {
+    DallasCommonRomData rom_data;
+    uint8_t sram_data[DS1992_SRAM_DATA_SIZE];
+    DS1992ProtocolState state;
+} DS1992ProtocolData;
+
+static bool dallas_ds1992_read(OneWireHost*, void*);
+static bool dallas_ds1992_write_blank(OneWireHost*, iButtonProtocolData*);
+static bool dallas_ds1992_write_copy(OneWireHost*, iButtonProtocolData*);
+static void dallas_ds1992_emulate(OneWireSlave*, iButtonProtocolData*);
+static bool dallas_ds1992_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
+static bool dallas_ds1992_save(FlipperFormat*, const iButtonProtocolData*);
+static void dallas_ds1992_render_data(FuriString*, const iButtonProtocolData*);
+static void dallas_ds1992_render_brief_data(FuriString*, const iButtonProtocolData*);
+static void dallas_ds1992_render_error(FuriString*, const iButtonProtocolData*);
+static bool dallas_ds1992_is_data_valid(const iButtonProtocolData*);
+static void dallas_ds1992_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
+static void dallas_ds1992_apply_edits(iButtonProtocolData*);
+
+const iButtonProtocolDallasBase ibutton_protocol_ds1992 = {
+    .family_code = DS1992_FAMILY_CODE,
+    .features = iButtonProtocolFeatureExtData | iButtonProtocolFeatureWriteBlank |
+                iButtonProtocolFeatureWriteCopy,
+    .data_size = sizeof(DS1992ProtocolData),
+    .manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
+    .name = DS1992_FAMILY_NAME,
+
+    .read = dallas_ds1992_read,
+    .write_blank = dallas_ds1992_write_blank,
+    .write_copy = dallas_ds1992_write_copy,
+    .emulate = dallas_ds1992_emulate,
+    .save = dallas_ds1992_save,
+    .load = dallas_ds1992_load,
+    .render_data = dallas_ds1992_render_data,
+    .render_brief_data = dallas_ds1992_render_brief_data,
+    .render_error = dallas_ds1992_render_error,
+    .is_valid = dallas_ds1992_is_data_valid,
+    .get_editable_data = dallas_ds1992_get_editable_data,
+    .apply_edits = dallas_ds1992_apply_edits,
+};
+
+bool dallas_ds1992_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data) &&
+           dallas_common_read_mem(host, 0, data->sram_data, DS1992_SRAM_DATA_SIZE);
+}
+
+bool dallas_ds1992_write_blank(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    // TODO: Make this work, currently broken
+    return tm2004_write(host, (uint8_t*)data, sizeof(DallasCommonRomData) + DS1992_SRAM_DATA_SIZE);
+}
+
+bool dallas_ds1992_write_copy(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    return dallas_common_write_mem(
+        host,
+        DS1992_COPY_SCRATCH_TIMEOUT_US,
+        DS1992_SRAM_PAGE_SIZE,
+        data->sram_data,
+        DS1992_SRAM_DATA_SIZE);
+}
+
+static void dallas_ds1992_reset_callback(void* context) {
+    furi_assert(context);
+    DS1992ProtocolData* data = context;
+    data->state.command_state = DallasCommonCommandStateIdle;
+}
+
+static bool dallas_ds1992_command_callback(uint8_t command, void* context) {
+    furi_assert(context);
+    DS1992ProtocolData* data = context;
+    OneWireSlave* bus = data->state.bus;
+
+    switch(command) {
+    case DALLAS_COMMON_CMD_SEARCH_ROM:
+        if(data->state.command_state == DallasCommonCommandStateIdle) {
+            data->state.command_state = DallasCommonCommandStateRomCmd;
+            return dallas_common_emulate_search_rom(bus, &data->rom_data);
+
+        } else if(data->state.command_state == DallasCommonCommandStateRomCmd) {
+            data->state.command_state = DallasCommonCommandStateMemCmd;
+            dallas_common_emulate_read_mem(bus, data->sram_data, DS1992_SRAM_DATA_SIZE);
+            return false;
+
+        } else {
+            return false;
+        }
+
+    case DALLAS_COMMON_CMD_READ_ROM:
+        if(data->state.command_state == DallasCommonCommandStateIdle) {
+            data->state.command_state = DallasCommonCommandStateRomCmd;
+            return dallas_common_emulate_read_rom(bus, &data->rom_data);
+        } else {
+            return false;
+        }
+
+    case DALLAS_COMMON_CMD_SKIP_ROM:
+        if(data->state.command_state == DallasCommonCommandStateIdle) {
+            data->state.command_state = DallasCommonCommandStateRomCmd;
+            return true;
+        } else {
+            return false;
+        }
+
+    default:
+        return false;
+    }
+}
+
+void dallas_ds1992_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    data->state.bus = bus;
+
+    onewire_slave_set_reset_callback(bus, dallas_ds1992_reset_callback, protocol_data);
+    onewire_slave_set_command_callback(bus, dallas_ds1992_command_callback, protocol_data);
+}
+
+bool dallas_ds1992_load(
+    FlipperFormat* ff,
+    uint32_t format_version,
+    iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    bool success = false;
+
+    do {
+        if(format_version < 2) break;
+        if(!dallas_common_load_rom_data(ff, format_version, &data->rom_data)) break;
+        if(!flipper_format_read_hex(
+               ff, DS1992_SRAM_DATA_KEY, data->sram_data, DS1992_SRAM_DATA_SIZE))
+            break;
+        success = true;
+    } while(false);
+
+    return success;
+}
+
+bool dallas_ds1992_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
+    const DS1992ProtocolData* data = protocol_data;
+    bool success = false;
+
+    do {
+        if(!dallas_common_save_rom_data(ff, &data->rom_data)) break;
+        if(!flipper_format_write_hex(
+               ff, DS1992_SRAM_DATA_KEY, data->sram_data, DS1992_SRAM_DATA_SIZE))
+            break;
+        success = true;
+    } while(false);
+
+    return success;
+}
+
+void dallas_ds1992_render_data(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1992ProtocolData* data = protocol_data;
+    pretty_format_bytes_hex_canonical(
+        result,
+        DS1992_DATA_BYTE_COUNT,
+        PRETTY_FORMAT_FONT_MONOSPACE,
+        data->sram_data,
+        DS1992_SRAM_DATA_SIZE);
+}
+
+void dallas_ds1992_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1992ProtocolData* data = protocol_data;
+    dallas_common_render_brief_data(
+        result, &data->rom_data, data->sram_data, DS1992_SRAM_DATA_SIZE);
+}
+
+void dallas_ds1992_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1992ProtocolData* data = protocol_data;
+
+    if(!dallas_common_is_valid_crc(&data->rom_data)) {
+        dallas_common_render_crc_error(result, &data->rom_data);
+    }
+}
+
+bool dallas_ds1992_is_data_valid(const iButtonProtocolData* protocol_data) {
+    const DS1992ProtocolData* data = protocol_data;
+    return dallas_common_is_valid_crc(&data->rom_data);
+}
+
+void dallas_ds1992_get_editable_data(
+    iButtonEditableData* editable_data,
+    iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    editable_data->ptr = data->rom_data.bytes;
+    editable_data->size = sizeof(DallasCommonRomData);
+}
+
+void dallas_ds1992_apply_edits(iButtonProtocolData* protocol_data) {
+    DS1992ProtocolData* data = protocol_data;
+    dallas_common_apply_edits(&data->rom_data, DS1992_FAMILY_CODE);
+}
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.h b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.h
new file mode 100644
index 0000000000..5a3c45f3be
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1992.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "protocol_dallas_base.h"
+
+extern const iButtonProtocolDallasBase ibutton_protocol_ds1992;
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.c b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.c
new file mode 100644
index 0000000000..e69145c58d
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.c
@@ -0,0 +1,212 @@
+#include "protocol_ds1996.h"
+
+#include <core/core_defines.h>
+#include <toolbox/pretty_format.h>
+
+#include "dallas_common.h"
+
+#define DS1996_FAMILY_CODE 0x0CU
+#define DS1996_FAMILY_NAME "DS1996"
+
+#define DS1996_SRAM_DATA_SIZE 8192U
+#define DS1996_SRAM_PAGE_SIZE 32U
+#define DS1996_COPY_SCRATCH_TIMEOUT_US 100U
+
+#define DS1996_DATA_BYTE_COUNT 4U
+
+#define DS1996_SRAM_DATA_KEY "Sram Data"
+
+typedef struct {
+    OneWireSlave* bus;
+    DallasCommonCommandState command_state;
+} DS1996ProtocolState;
+
+typedef struct {
+    DallasCommonRomData rom_data;
+    uint8_t sram_data[DS1996_SRAM_DATA_SIZE];
+    DS1996ProtocolState state;
+} DS1996ProtocolData;
+
+static bool dallas_ds1996_read(OneWireHost*, void*);
+static bool dallas_ds1996_write_copy(OneWireHost*, iButtonProtocolData*);
+static void dallas_ds1996_emulate(OneWireSlave*, iButtonProtocolData*);
+static bool dallas_ds1996_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
+static bool dallas_ds1996_save(FlipperFormat*, const iButtonProtocolData*);
+static void dallas_ds1996_render_data(FuriString*, const iButtonProtocolData*);
+static void dallas_ds1996_render_brief_data(FuriString*, const iButtonProtocolData*);
+static void dallas_ds1996_render_error(FuriString*, const iButtonProtocolData*);
+static bool dallas_ds1996_is_data_valid(const iButtonProtocolData*);
+static void dallas_ds1996_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
+static void dallas_ds1996_apply_edits(iButtonProtocolData*);
+
+const iButtonProtocolDallasBase ibutton_protocol_ds1996 = {
+    .family_code = DS1996_FAMILY_CODE,
+    .features = iButtonProtocolFeatureExtData | iButtonProtocolFeatureWriteCopy,
+    .data_size = sizeof(DS1996ProtocolData),
+    .manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
+    .name = DS1996_FAMILY_NAME,
+
+    .read = dallas_ds1996_read,
+    .write_blank = NULL, /* Data too big for known blanks */
+    .write_copy = dallas_ds1996_write_copy,
+    .emulate = dallas_ds1996_emulate,
+    .save = dallas_ds1996_save,
+    .load = dallas_ds1996_load,
+    .render_data = dallas_ds1996_render_data,
+    .render_brief_data = dallas_ds1996_render_brief_data,
+    .render_error = dallas_ds1996_render_error,
+    .is_valid = dallas_ds1996_is_data_valid,
+    .get_editable_data = dallas_ds1996_get_editable_data,
+    .apply_edits = dallas_ds1996_apply_edits,
+};
+
+bool dallas_ds1996_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1996ProtocolData* data = protocol_data;
+    return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data) &&
+           dallas_common_read_mem(host, 0, data->sram_data, DS1996_SRAM_DATA_SIZE);
+}
+
+bool dallas_ds1996_write_copy(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DS1996ProtocolData* data = protocol_data;
+    return dallas_common_write_mem(
+        host,
+        DS1996_COPY_SCRATCH_TIMEOUT_US,
+        DS1996_SRAM_PAGE_SIZE,
+        data->sram_data,
+        DS1996_SRAM_DATA_SIZE);
+}
+
+static void dallas_ds1996_reset_callback(void* context) {
+    furi_assert(context);
+    DS1996ProtocolData* data = context;
+    data->state.command_state = DallasCommonCommandStateIdle;
+}
+
+static bool dallas_ds1996_command_callback(uint8_t command, void* context) {
+    furi_assert(context);
+    DS1996ProtocolData* data = context;
+    OneWireSlave* bus = data->state.bus;
+
+    switch(command) {
+    case DALLAS_COMMON_CMD_SEARCH_ROM:
+        if(data->state.command_state == DallasCommonCommandStateIdle) {
+            data->state.command_state = DallasCommonCommandStateRomCmd;
+            return dallas_common_emulate_search_rom(bus, &data->rom_data);
+
+        } else if(data->state.command_state == DallasCommonCommandStateRomCmd) {
+            data->state.command_state = DallasCommonCommandStateMemCmd;
+            dallas_common_emulate_read_mem(bus, data->sram_data, DS1996_SRAM_DATA_SIZE);
+            return false;
+
+        } else {
+            return false;
+        }
+
+    case DALLAS_COMMON_CMD_READ_ROM:
+        if(data->state.command_state == DallasCommonCommandStateIdle) {
+            data->state.command_state = DallasCommonCommandStateRomCmd;
+            return dallas_common_emulate_read_rom(bus, &data->rom_data);
+        } else {
+            return false;
+        }
+
+    case DALLAS_COMMON_CMD_SKIP_ROM:
+        if(data->state.command_state == DallasCommonCommandStateIdle) {
+            data->state.command_state = DallasCommonCommandStateRomCmd;
+            return true;
+        } else {
+            return false;
+        }
+
+    case DALLAS_COMMON_CMD_OVERDRIVE_SKIP_ROM:
+    case DALLAS_COMMON_CMD_OVERDRIVE_MATCH_ROM:
+        /* TODO: Overdrive mode support */
+    default:
+        return false;
+    }
+}
+
+void dallas_ds1996_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
+    DS1996ProtocolData* data = protocol_data;
+    data->state.bus = bus;
+
+    onewire_slave_set_reset_callback(bus, dallas_ds1996_reset_callback, protocol_data);
+    onewire_slave_set_command_callback(bus, dallas_ds1996_command_callback, protocol_data);
+}
+
+bool dallas_ds1996_load(
+    FlipperFormat* ff,
+    uint32_t format_version,
+    iButtonProtocolData* protocol_data) {
+    DS1996ProtocolData* data = protocol_data;
+    bool success = false;
+
+    do {
+        if(format_version < 2) break;
+        if(!dallas_common_load_rom_data(ff, format_version, &data->rom_data)) break;
+        if(!flipper_format_read_hex(
+               ff, DS1996_SRAM_DATA_KEY, data->sram_data, DS1996_SRAM_DATA_SIZE))
+            break;
+        success = true;
+    } while(false);
+
+    return success;
+}
+
+bool dallas_ds1996_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
+    const DS1996ProtocolData* data = protocol_data;
+    bool success = false;
+
+    do {
+        if(!dallas_common_save_rom_data(ff, &data->rom_data)) break;
+        if(!flipper_format_write_hex(
+               ff, DS1996_SRAM_DATA_KEY, data->sram_data, DS1996_SRAM_DATA_SIZE))
+            break;
+        success = true;
+    } while(false);
+
+    return success;
+}
+
+void dallas_ds1996_render_data(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1996ProtocolData* data = protocol_data;
+
+    pretty_format_bytes_hex_canonical(
+        result,
+        DS1996_DATA_BYTE_COUNT,
+        PRETTY_FORMAT_FONT_MONOSPACE,
+        data->sram_data,
+        DS1996_SRAM_DATA_SIZE);
+}
+
+void dallas_ds1996_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1996ProtocolData* data = protocol_data;
+    dallas_common_render_brief_data(
+        result, &data->rom_data, data->sram_data, DS1996_SRAM_DATA_SIZE);
+}
+
+void dallas_ds1996_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DS1996ProtocolData* data = protocol_data;
+
+    if(!dallas_common_is_valid_crc(&data->rom_data)) {
+        dallas_common_render_crc_error(result, &data->rom_data);
+    }
+}
+
+bool dallas_ds1996_is_data_valid(const iButtonProtocolData* protocol_data) {
+    const DS1996ProtocolData* data = protocol_data;
+    return dallas_common_is_valid_crc(&data->rom_data);
+}
+
+void dallas_ds1996_get_editable_data(
+    iButtonEditableData* editable_data,
+    iButtonProtocolData* protocol_data) {
+    DS1996ProtocolData* data = protocol_data;
+    editable_data->ptr = data->rom_data.bytes;
+    editable_data->size = sizeof(DallasCommonRomData);
+}
+
+void dallas_ds1996_apply_edits(iButtonProtocolData* protocol_data) {
+    DS1996ProtocolData* data = protocol_data;
+    dallas_common_apply_edits(&data->rom_data, DS1996_FAMILY_CODE);
+}
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.h b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.h
new file mode 100644
index 0000000000..34546985b4
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds1996.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "protocol_dallas_base.h"
+
+extern const iButtonProtocolDallasBase ibutton_protocol_ds1996;
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.c b/lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.c
new file mode 100644
index 0000000000..50fd045112
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.c
@@ -0,0 +1,133 @@
+#include "protocol_ds_generic.h"
+
+#include <core/string.h>
+#include <core/core_defines.h>
+
+#include "dallas_common.h"
+
+#include "../blanks/tm2004.h"
+
+#define DALLAS_GENERIC_FAMILY_CODE 0x00U
+#define DALLAS_GENERIC_FAMILY_NAME "DSGeneric"
+
+typedef struct {
+    OneWireSlave* bus;
+} DallasGenericProtocolState;
+
+typedef struct {
+    DallasCommonRomData rom_data;
+    DallasGenericProtocolState state;
+} DallasGenericProtocolData;
+
+static bool ds_generic_read(OneWireHost*, iButtonProtocolData*);
+static bool ds_generic_write_blank(OneWireHost*, iButtonProtocolData*);
+static void ds_generic_emulate(OneWireSlave*, iButtonProtocolData*);
+static bool ds_generic_load(FlipperFormat*, uint32_t, iButtonProtocolData*);
+static bool ds_generic_save(FlipperFormat*, const iButtonProtocolData*);
+static void ds_generic_render_brief_data(FuriString*, const iButtonProtocolData*);
+static void ds_generic_render_error(FuriString*, const iButtonProtocolData*);
+static bool ds_generic_is_data_valid(const iButtonProtocolData*);
+static void ds_generic_get_editable_data(iButtonEditableData*, iButtonProtocolData*);
+static void ds_generic_apply_edits(iButtonProtocolData*);
+
+const iButtonProtocolDallasBase ibutton_protocol_ds_generic = {
+    .family_code = DALLAS_GENERIC_FAMILY_CODE,
+    .features = iButtonProtocolFeatureWriteBlank,
+    .data_size = sizeof(DallasGenericProtocolData),
+    .manufacturer = DALLAS_COMMON_MANUFACTURER_NAME,
+    .name = DALLAS_GENERIC_FAMILY_NAME,
+
+    .read = ds_generic_read,
+    .write_blank = ds_generic_write_blank,
+    .write_copy = NULL, /* No data to write a copy */
+    .emulate = ds_generic_emulate,
+    .save = ds_generic_save,
+    .load = ds_generic_load,
+    .render_data = NULL, /* No data to render */
+    .render_brief_data = ds_generic_render_brief_data,
+    .render_error = ds_generic_render_error,
+    .is_valid = ds_generic_is_data_valid,
+    .get_editable_data = ds_generic_get_editable_data,
+    .apply_edits = ds_generic_apply_edits,
+};
+
+bool ds_generic_read(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DallasGenericProtocolData* data = protocol_data;
+    return onewire_host_reset(host) && dallas_common_read_rom(host, &data->rom_data);
+}
+
+bool ds_generic_write_blank(OneWireHost* host, iButtonProtocolData* protocol_data) {
+    DallasGenericProtocolData* data = protocol_data;
+    return tm2004_write(host, data->rom_data.bytes, sizeof(DallasCommonRomData));
+}
+
+static bool ds_generic_command_callback(uint8_t command, void* context) {
+    furi_assert(context);
+    DallasGenericProtocolData* data = context;
+    OneWireSlave* bus = data->state.bus;
+
+    switch(command) {
+    case DALLAS_COMMON_CMD_SEARCH_ROM:
+        dallas_common_emulate_search_rom(bus, &data->rom_data);
+        break;
+    case DALLAS_COMMON_CMD_READ_ROM:
+        dallas_common_emulate_read_rom(bus, &data->rom_data);
+        break;
+    default:
+        break;
+    }
+
+    // No support for multiple consecutive commands
+    return false;
+}
+
+void ds_generic_emulate(OneWireSlave* bus, iButtonProtocolData* protocol_data) {
+    DallasGenericProtocolData* data = protocol_data;
+    data->state.bus = bus;
+
+    onewire_slave_set_reset_callback(bus, NULL, NULL);
+    onewire_slave_set_command_callback(bus, ds_generic_command_callback, protocol_data);
+}
+
+bool ds_generic_save(FlipperFormat* ff, const iButtonProtocolData* protocol_data) {
+    const DallasGenericProtocolData* data = protocol_data;
+    return dallas_common_save_rom_data(ff, &data->rom_data);
+}
+
+bool ds_generic_load(
+    FlipperFormat* ff,
+    uint32_t format_version,
+    iButtonProtocolData* protocol_data) {
+    DallasGenericProtocolData* data = protocol_data;
+    return dallas_common_load_rom_data(ff, format_version, &data->rom_data);
+}
+
+void ds_generic_render_brief_data(FuriString* result, const iButtonProtocolData* protocol_data) {
+    const DallasGenericProtocolData* data = protocol_data;
+
+    for(size_t i = 0; i < sizeof(DallasCommonRomData); ++i) {
+        furi_string_cat_printf(result, "%02X ", data->rom_data.bytes[i]);
+    }
+}
+
+void ds_generic_render_error(FuriString* result, const iButtonProtocolData* protocol_data) {
+    UNUSED(result);
+    UNUSED(protocol_data);
+}
+
+bool ds_generic_is_data_valid(const iButtonProtocolData* protocol_data) {
+    UNUSED(protocol_data);
+    return true;
+}
+
+void ds_generic_get_editable_data(
+    iButtonEditableData* editable_data,
+    iButtonProtocolData* protocol_data) {
+    DallasGenericProtocolData* data = protocol_data;
+    editable_data->ptr = data->rom_data.bytes;
+    editable_data->size = sizeof(DallasCommonRomData);
+}
+
+void ds_generic_apply_edits(iButtonProtocolData* protocol_data) {
+    UNUSED(protocol_data);
+}
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.h b/lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.h
new file mode 100644
index 0000000000..008f8a67b0
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_ds_generic.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "protocol_dallas_base.h"
+
+extern const iButtonProtocolDallasBase ibutton_protocol_ds_generic;
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.c b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.c
new file mode 100644
index 0000000000..d0ffa511b4
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.c
@@ -0,0 +1,310 @@
+#include "protocol_group_dallas.h"
+
+#include <furi_hal_resources.h>
+
+#include "protocol_group_dallas_defs.h"
+
+#define IBUTTON_ONEWIRE_ROM_SIZE 8U
+
+typedef struct {
+    OneWireHost* host;
+    OneWireSlave* bus;
+} iButtonProtocolGroupDallas;
+
+static iButtonProtocolGroupDallas* ibutton_protocol_group_dallas_alloc() {
+    iButtonProtocolGroupDallas* group = malloc(sizeof(iButtonProtocolGroupDallas));
+
+    group->host = onewire_host_alloc(&ibutton_gpio);
+    group->bus = onewire_slave_alloc(&ibutton_gpio);
+
+    return group;
+}
+
+static void ibutton_protocol_group_dallas_free(iButtonProtocolGroupDallas* group) {
+    onewire_slave_free(group->bus);
+    onewire_host_free(group->host);
+    free(group);
+}
+
+static size_t ibutton_protocol_group_dallas_get_max_data_size(iButtonProtocolGroupDallas* group) {
+    UNUSED(group);
+    size_t max_data_size = 0;
+
+    for(iButtonProtocolLocalId i = 0; i < iButtonProtocolDSMax; ++i) {
+        const size_t current_rom_size = ibutton_protocols_dallas[i]->data_size;
+        if(current_rom_size > max_data_size) {
+            max_data_size = current_rom_size;
+        }
+    }
+
+    return max_data_size;
+}
+
+static bool ibutton_protocol_group_dallas_get_id_by_name(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolLocalId* id,
+    const char* name) {
+    UNUSED(group);
+    // Handle older key files which refer to DS1990 as just "Dallas"
+    if(strcmp(name, "Dallas") == 0) {
+        *id = iButtonProtocolDS1990;
+        return true;
+    }
+
+    for(iButtonProtocolLocalId i = 0; i < iButtonProtocolDSMax; ++i) {
+        if(strcmp(ibutton_protocols_dallas[i]->name, name) == 0) {
+            *id = i;
+            return true;
+        }
+    }
+    return false;
+}
+
+static uint32_t ibutton_protocol_group_dallas_get_features(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    return ibutton_protocols_dallas[id]->features;
+}
+
+static const char* ibutton_protocol_group_dallas_get_manufacturer(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    return ibutton_protocols_dallas[id]->manufacturer;
+}
+
+static const char* ibutton_protocol_group_dallas_get_name(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    return ibutton_protocols_dallas[id]->name;
+}
+
+static iButtonProtocolLocalId
+    ibutton_protocol_group_dallas_get_id_by_family_code(uint8_t family_code) {
+    iButtonProtocolLocalId id;
+
+    for(id = 0; id < iButtonProtocolDSGeneric; ++id) {
+        if(ibutton_protocols_dallas[id]->family_code == family_code) break;
+    }
+
+    return id;
+}
+
+static bool ibutton_protocol_group_dallas_read(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId* id) {
+    bool success = false;
+    uint8_t rom_data[IBUTTON_ONEWIRE_ROM_SIZE];
+    OneWireHost* host = group->host;
+
+    onewire_host_start(host);
+    furi_delay_ms(100);
+
+    FURI_CRITICAL_ENTER();
+
+    if(onewire_host_search(host, rom_data, OneWireHostSearchModeNormal)) {
+        /* Considering any found 1-Wire device a success.
+         * It can be checked later with ibutton_key_is_valid(). */
+        success = true;
+
+        /* If a 1-Wire device was found, id is guaranteed to be
+         * one of the known keys or DSGeneric. */
+        *id = ibutton_protocol_group_dallas_get_id_by_family_code(rom_data[0]);
+        ibutton_protocols_dallas[*id]->read(host, data);
+    }
+
+    onewire_host_reset_search(host);
+    onewire_host_stop(host);
+
+    FURI_CRITICAL_EXIT();
+
+    return success;
+}
+
+static bool ibutton_protocol_group_dallas_write_blank(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    furi_assert(id < iButtonProtocolDSMax);
+    const iButtonProtocolDallasBase* protocol = ibutton_protocols_dallas[id];
+    furi_assert(protocol->features & iButtonProtocolFeatureWriteBlank);
+
+    OneWireHost* host = group->host;
+
+    onewire_host_start(host);
+    furi_delay_ms(100);
+
+    FURI_CRITICAL_ENTER();
+
+    const bool success = protocol->write_blank(host, data);
+    onewire_host_stop(host);
+
+    FURI_CRITICAL_EXIT();
+    return success;
+}
+
+static bool ibutton_protocol_group_dallas_write_copy(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    furi_assert(id < iButtonProtocolDSMax);
+
+    const iButtonProtocolDallasBase* protocol = ibutton_protocols_dallas[id];
+    furi_assert(protocol->features & iButtonProtocolFeatureWriteCopy);
+
+    OneWireHost* host = group->host;
+
+    onewire_host_start(host);
+    furi_delay_ms(100);
+
+    FURI_CRITICAL_ENTER();
+
+    const bool success = protocol->write_copy(host, data);
+    onewire_host_stop(host);
+
+    FURI_CRITICAL_EXIT();
+    return success;
+}
+
+static void ibutton_protocol_group_dallas_emulate_start(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    furi_assert(id < iButtonProtocolDSMax);
+    OneWireSlave* bus = group->bus;
+    ibutton_protocols_dallas[id]->emulate(bus, data);
+    onewire_slave_start(bus);
+}
+
+static void ibutton_protocol_group_dallas_emulate_stop(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    furi_assert(id < iButtonProtocolDSMax);
+    UNUSED(data);
+    onewire_slave_stop(group->bus);
+}
+
+static bool ibutton_protocol_group_dallas_save(
+    iButtonProtocolGroupDallas* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FlipperFormat* ff) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    return ibutton_protocols_dallas[id]->save(ff, data);
+}
+
+static bool ibutton_protocol_group_dallas_load(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    uint32_t version,
+    FlipperFormat* ff) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    return ibutton_protocols_dallas[id]->load(ff, version, data);
+}
+
+static void ibutton_protocol_group_dallas_render_data(
+    iButtonProtocolGroupDallas* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FuriString* result) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    const iButtonProtocolDallasBase* protocol = ibutton_protocols_dallas[id];
+    furi_assert(protocol->render_data);
+    protocol->render_data(result, data);
+}
+
+static void ibutton_protocol_group_dallas_render_brief_data(
+    iButtonProtocolGroupDallas* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FuriString* result) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    ibutton_protocols_dallas[id]->render_brief_data(result, data);
+}
+
+static void ibutton_protocol_group_dallas_render_error(
+    iButtonProtocolGroupDallas* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FuriString* result) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    ibutton_protocols_dallas[id]->render_error(result, data);
+}
+
+static bool ibutton_protocol_group_dallas_is_valid(
+    iButtonProtocolGroupDallas* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    return ibutton_protocols_dallas[id]->is_valid(data);
+}
+
+static void ibutton_protocol_group_dallas_get_editable_data(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    iButtonEditableData* editable) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    ibutton_protocols_dallas[id]->get_editable_data(editable, data);
+}
+
+static void ibutton_protocol_group_dallas_apply_edits(
+    iButtonProtocolGroupDallas* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    furi_assert(id < iButtonProtocolDSMax);
+    ibutton_protocols_dallas[id]->apply_edits(data);
+}
+
+const iButtonProtocolGroupBase ibutton_protocol_group_dallas = {
+    .protocol_count = iButtonProtocolDSMax,
+
+    .alloc = (iButtonProtocolGroupAllocFunc)ibutton_protocol_group_dallas_alloc,
+    .free = (iButtonProtocolGroupFreeFunc)ibutton_protocol_group_dallas_free,
+
+    .get_max_data_size =
+        (iButtonProtocolGropuGetSizeFunc)ibutton_protocol_group_dallas_get_max_data_size,
+    .get_id_by_name = (iButtonProtocolGroupGetIdFunc)ibutton_protocol_group_dallas_get_id_by_name,
+    .get_features =
+        (iButtonProtocolGroupGetFeaturesFunc)ibutton_protocol_group_dallas_get_features,
+
+    .get_manufacturer =
+        (iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_dallas_get_manufacturer,
+    .get_name = (iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_dallas_get_name,
+
+    .read = (iButtonProtocolGroupReadFunc)ibutton_protocol_group_dallas_read,
+    .write_blank = (iButtonProtocolGroupWriteFunc)ibutton_protocol_group_dallas_write_blank,
+    .write_copy = (iButtonProtocolGroupWriteFunc)ibutton_protocol_group_dallas_write_copy,
+
+    .emulate_start = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_dallas_emulate_start,
+    .emulate_stop = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_dallas_emulate_stop,
+
+    .save = (iButtonProtocolGroupSaveFunc)ibutton_protocol_group_dallas_save,
+    .load = (iButtonProtocolGroupLoadFunc)ibutton_protocol_group_dallas_load,
+
+    .render_data = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_dallas_render_data,
+    .render_brief_data =
+        (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_dallas_render_brief_data,
+    .render_error = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_dallas_render_error,
+
+    .is_valid = (iButtonProtocolGroupIsValidFunc)ibutton_protocol_group_dallas_is_valid,
+    .get_editable_data =
+        (iButtonProtocolGroupGetDataFunc)ibutton_protocol_group_dallas_get_editable_data,
+    .apply_edits = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_dallas_apply_edits,
+};
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.h b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.h
new file mode 100644
index 0000000000..d1293c71b8
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../protocol_group_base.h"
+
+extern const iButtonProtocolGroupBase ibutton_protocol_group_dallas;
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.c b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.c
new file mode 100644
index 0000000000..e54c3125d7
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.c
@@ -0,0 +1,16 @@
+#include "protocol_group_dallas_defs.h"
+
+#include "protocol_ds1990.h"
+#include "protocol_ds1992.h"
+#include "protocol_ds1996.h"
+#include "protocol_ds_generic.h"
+
+const iButtonProtocolDallasBase* ibutton_protocols_dallas[] = {
+    [iButtonProtocolDS1990] = &ibutton_protocol_ds1990,
+    [iButtonProtocolDS1992] = &ibutton_protocol_ds1992,
+    [iButtonProtocolDS1996] = &ibutton_protocol_ds1996,
+    /* Add new 1-Wire protocols here */
+
+    /* Default catch-all 1-Wire protocol */
+    [iButtonProtocolDSGeneric] = &ibutton_protocol_ds_generic,
+};
diff --git a/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.h b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.h
new file mode 100644
index 0000000000..ba74c0c236
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/dallas/protocol_group_dallas_defs.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "protocol_dallas_base.h"
+
+typedef enum {
+    iButtonProtocolDS1990,
+    iButtonProtocolDS1992,
+    iButtonProtocolDS1996,
+    /* Add new 1-Wire protocols here */
+
+    /* Default catch-all 1-Wire protocol */
+    iButtonProtocolDSGeneric,
+    iButtonProtocolDSMax,
+} iButtonProtocolDallas;
+
+extern const iButtonProtocolDallasBase* ibutton_protocols_dallas[];
diff --git a/lib/one_wire/ibutton/protocols/ibutton_protocols.c b/lib/one_wire/ibutton/protocols/ibutton_protocols.c
deleted file mode 100644
index b07d68b33c..0000000000
--- a/lib/one_wire/ibutton/protocols/ibutton_protocols.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "ibutton_protocols.h"
-#include "protocol_cyfral.h"
-#include "protocol_metakom.h"
-
-const ProtocolBase* ibutton_protocols[] = {
-    [iButtonProtocolCyfral] = &protocol_cyfral,
-    [iButtonProtocolMetakom] = &protocol_metakom,
-};
\ No newline at end of file
diff --git a/lib/one_wire/ibutton/protocols/ibutton_protocols.h b/lib/one_wire/ibutton/protocols/ibutton_protocols.h
deleted file mode 100644
index cdaa3ab6fa..0000000000
--- a/lib/one_wire/ibutton/protocols/ibutton_protocols.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-#include "toolbox/protocols/protocol.h"
-
-typedef enum {
-    iButtonProtocolCyfral,
-    iButtonProtocolMetakom,
-
-    iButtonProtocolMax,
-} iButtonProtocol;
-
-extern const ProtocolBase* ibutton_protocols[];
\ No newline at end of file
diff --git a/lib/one_wire/ibutton/protocols/protocol_cyfral.c b/lib/one_wire/ibutton/protocols/misc/protocol_cyfral.c
similarity index 96%
rename from lib/one_wire/ibutton/protocols/protocol_cyfral.c
rename to lib/one_wire/ibutton/protocols/misc/protocol_cyfral.c
index a5f459bc04..0cdb8766b0 100644
--- a/lib/one_wire/ibutton/protocols/protocol_cyfral.c
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_cyfral.c
@@ -1,5 +1,6 @@
 #include <furi.h>
 #include <furi_hal.h>
+
 #include "protocol_cyfral.h"
 
 #define CYFRAL_DATA_SIZE sizeof(uint16_t)
@@ -324,7 +325,13 @@ static LevelDuration protocol_cyfral_encoder_yield(ProtocolCyfral* proto) {
     return result;
 }
 
-const ProtocolBase protocol_cyfral = {
+static void protocol_cyfral_render_brief_data(ProtocolCyfral* proto, FuriString* result) {
+    for(size_t i = 0; i < CYFRAL_DATA_SIZE; ++i) {
+        furi_string_cat_printf(result, "%02X ", ((uint8_t*)&proto->data)[i]);
+    }
+}
+
+const ProtocolBase ibutton_protocol_misc_cyfral = {
     .name = "Cyfral",
     .manufacturer = "Cyfral",
     .data_size = CYFRAL_DATA_SIZE,
@@ -341,4 +348,5 @@ const ProtocolBase protocol_cyfral = {
             .start = (ProtocolEncoderStart)protocol_cyfral_encoder_start,
             .yield = (ProtocolEncoderYield)protocol_cyfral_encoder_yield,
         },
+    .render_brief_data = (ProtocolRenderData)protocol_cyfral_render_brief_data,
 };
diff --git a/lib/one_wire/ibutton/protocols/misc/protocol_cyfral.h b/lib/one_wire/ibutton/protocols/misc/protocol_cyfral.h
new file mode 100644
index 0000000000..08b8eef816
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_cyfral.h
@@ -0,0 +1,4 @@
+#pragma once
+#include "toolbox/protocols/protocol.h"
+
+extern const ProtocolBase ibutton_protocol_misc_cyfral;
diff --git a/lib/one_wire/ibutton/protocols/misc/protocol_group_misc.c b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc.c
new file mode 100644
index 0000000000..dad1ef3cfe
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc.c
@@ -0,0 +1,295 @@
+#include "protocol_group_misc.h"
+
+#include <furi_hal_rfid.h>
+#include <furi_hal_ibutton.h>
+
+#include <toolbox/protocols/protocol_dict.h>
+
+#include "protocol_group_misc_defs.h"
+
+#define IBUTTON_MISC_READ_TIMEOUT 100
+
+#define IBUTTON_MISC_DATA_KEY_KEY_COMMON "Data"
+
+typedef struct {
+    ProtocolDict* dict;
+    ProtocolId emulate_id;
+} iButtonProtocolGroupMisc;
+
+static iButtonProtocolGroupMisc* ibutton_protocol_group_misc_alloc() {
+    iButtonProtocolGroupMisc* group = malloc(sizeof(iButtonProtocolGroupMisc));
+
+    group->dict = protocol_dict_alloc(ibutton_protocols_misc, iButtonProtocolMiscMax);
+    group->emulate_id = PROTOCOL_NO;
+
+    return group;
+}
+
+static void ibutton_protocol_group_misc_free(iButtonProtocolGroupMisc* group) {
+    protocol_dict_free(group->dict);
+    free(group);
+}
+
+static size_t ibutton_protocol_group_misc_get_max_data_size(iButtonProtocolGroupMisc* group) {
+    return protocol_dict_get_max_data_size(group->dict);
+}
+
+static bool ibutton_protocol_group_misc_get_id_by_name(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolLocalId* id,
+    const char* name) {
+    const ProtocolId found_id = protocol_dict_get_protocol_by_name(group->dict, name);
+
+    if(found_id != PROTOCOL_NO) {
+        *id = found_id;
+        return true;
+    }
+    return false;
+}
+
+static uint32_t ibutton_protocol_group_misc_get_features(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    UNUSED(id);
+    return 0;
+}
+
+static const char* ibutton_protocol_group_misc_get_manufacturer(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolLocalId id) {
+    return protocol_dict_get_manufacturer(group->dict, id);
+}
+
+static const char* ibutton_protocol_group_misc_get_name(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolLocalId id) {
+    return protocol_dict_get_name(group->dict, id);
+}
+
+typedef struct {
+    uint32_t last_dwt_value;
+    FuriStreamBuffer* stream;
+} iButtonReadContext;
+
+static void ibutton_protocols_comparator_callback(bool level, void* context) {
+    iButtonReadContext* read_context = context;
+
+    uint32_t current_dwt_value = DWT->CYCCNT;
+
+    LevelDuration data =
+        level_duration_make(level, current_dwt_value - read_context->last_dwt_value);
+    furi_stream_buffer_send(read_context->stream, &data, sizeof(LevelDuration), 0);
+
+    read_context->last_dwt_value = current_dwt_value;
+}
+
+static bool ibutton_protocol_group_misc_read(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId* id) {
+    bool result = false;
+
+    protocol_dict_decoders_start(group->dict);
+
+    furi_hal_rfid_pins_reset();
+    // pulldown pull pin, we sense the signal through the analog part of the RFID schematic
+    furi_hal_rfid_pin_pull_pulldown();
+
+    iButtonReadContext read_context = {
+        .last_dwt_value = DWT->CYCCNT,
+        .stream = furi_stream_buffer_alloc(sizeof(LevelDuration) * 512, 1),
+    };
+
+    furi_hal_rfid_comp_set_callback(ibutton_protocols_comparator_callback, &read_context);
+    furi_hal_rfid_comp_start();
+
+    const uint32_t tick_start = furi_get_tick();
+
+    for(;;) {
+        LevelDuration level;
+        size_t ret = furi_stream_buffer_receive(
+            read_context.stream, &level, sizeof(LevelDuration), IBUTTON_MISC_READ_TIMEOUT);
+
+        if((furi_get_tick() - tick_start) > IBUTTON_MISC_READ_TIMEOUT) {
+            break;
+        }
+
+        if(ret > 0) {
+            ProtocolId decoded_index = protocol_dict_decoders_feed(
+                group->dict, level_duration_get_level(level), level_duration_get_duration(level));
+
+            if(decoded_index == PROTOCOL_NO) continue;
+
+            *id = decoded_index;
+
+            protocol_dict_get_data(
+                group->dict,
+                decoded_index,
+                data,
+                protocol_dict_get_data_size(group->dict, decoded_index));
+
+            result = true;
+        }
+    }
+
+    furi_hal_rfid_comp_stop();
+    furi_hal_rfid_comp_set_callback(NULL, NULL);
+    furi_hal_rfid_pins_reset();
+
+    furi_stream_buffer_free(read_context.stream);
+
+    return result;
+}
+
+static void ibutton_protocol_group_misc_emulate_callback(void* context) {
+    iButtonProtocolGroupMisc* group = context;
+
+    const LevelDuration level_duration =
+        protocol_dict_encoder_yield(group->dict, group->emulate_id);
+
+    furi_hal_ibutton_emulate_set_next(level_duration_get_duration(level_duration));
+    furi_hal_ibutton_pin_write(level_duration_get_level(level_duration));
+}
+
+static void ibutton_protocol_group_misc_emulate_start(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    group->emulate_id = id;
+    protocol_dict_set_data(group->dict, id, data, protocol_dict_get_data_size(group->dict, id));
+    protocol_dict_encoder_start(group->dict, group->emulate_id);
+
+    furi_hal_ibutton_pin_configure();
+    furi_hal_ibutton_emulate_start(0, ibutton_protocol_group_misc_emulate_callback, group);
+}
+
+static void ibutton_protocol_group_misc_emulate_stop(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    UNUSED(data);
+    UNUSED(id);
+    furi_hal_ibutton_emulate_stop();
+    furi_hal_ibutton_pin_reset();
+}
+
+static bool ibutton_protocol_group_misc_save(
+    iButtonProtocolGroupMisc* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FlipperFormat* ff) {
+    const size_t data_size = protocol_dict_get_data_size(group->dict, id);
+    return flipper_format_write_hex(ff, IBUTTON_MISC_DATA_KEY_KEY_COMMON, data, data_size);
+}
+
+static bool ibutton_protocol_group_misc_load(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    uint32_t version,
+    FlipperFormat* ff) {
+    const size_t data_size = protocol_dict_get_data_size(group->dict, id);
+    switch(version) {
+    case 1:
+    case 2:
+        return flipper_format_read_hex(ff, IBUTTON_MISC_DATA_KEY_KEY_COMMON, data, data_size);
+    default:
+        return false;
+    }
+}
+
+static void ibutton_protocol_group_misc_render_data(
+    iButtonProtocolGroupMisc* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FuriString* result) {
+    const size_t data_size = protocol_dict_get_data_size(group->dict, id);
+    protocol_dict_set_data(group->dict, id, data, data_size);
+    protocol_dict_render_data(group->dict, result, id);
+}
+
+static void ibutton_protocol_group_misc_render_brief_data(
+    iButtonProtocolGroupMisc* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FuriString* result) {
+    const size_t data_size = protocol_dict_get_data_size(group->dict, id);
+    protocol_dict_set_data(group->dict, id, data, data_size);
+    protocol_dict_render_brief_data(group->dict, result, id);
+}
+
+static void ibutton_protocol_group_misc_render_error(
+    iButtonProtocolGroupMisc* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    FuriString* result) {
+    UNUSED(group);
+    UNUSED(data);
+    UNUSED(id);
+    UNUSED(result);
+}
+
+static bool ibutton_protocol_group_misc_is_valid(
+    iButtonProtocolGroupMisc* group,
+    const iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    UNUSED(group);
+    UNUSED(data);
+    UNUSED(id);
+    return true;
+}
+
+static void ibutton_protocol_group_misc_get_editable_data(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id,
+    iButtonEditableData* editable) {
+    editable->ptr = data;
+    editable->size = protocol_dict_get_data_size(group->dict, id);
+}
+
+static void ibutton_protocol_group_misc_apply_edits(
+    iButtonProtocolGroupMisc* group,
+    iButtonProtocolData* data,
+    iButtonProtocolLocalId id) {
+    const size_t data_size = protocol_dict_get_data_size(group->dict, id);
+    protocol_dict_set_data(group->dict, id, data, data_size);
+}
+
+const iButtonProtocolGroupBase ibutton_protocol_group_misc = {
+    .protocol_count = iButtonProtocolMiscMax,
+
+    .alloc = (iButtonProtocolGroupAllocFunc)ibutton_protocol_group_misc_alloc,
+    .free = (iButtonProtocolGroupFreeFunc)ibutton_protocol_group_misc_free,
+
+    .get_max_data_size =
+        (iButtonProtocolGropuGetSizeFunc)ibutton_protocol_group_misc_get_max_data_size,
+    .get_id_by_name = (iButtonProtocolGroupGetIdFunc)ibutton_protocol_group_misc_get_id_by_name,
+    .get_features = (iButtonProtocolGroupGetFeaturesFunc)ibutton_protocol_group_misc_get_features,
+
+    .get_manufacturer =
+        (iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_misc_get_manufacturer,
+    .get_name = (iButtonProtocolGroupGetStringFunc)ibutton_protocol_group_misc_get_name,
+
+    .read = (iButtonProtocolGroupReadFunc)ibutton_protocol_group_misc_read,
+    .write_blank = NULL,
+    .write_copy = NULL,
+
+    .emulate_start = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_misc_emulate_start,
+    .emulate_stop = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_misc_emulate_stop,
+
+    .save = (iButtonProtocolGroupSaveFunc)ibutton_protocol_group_misc_save,
+    .load = (iButtonProtocolGroupLoadFunc)ibutton_protocol_group_misc_load,
+
+    .render_data = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_misc_render_data,
+    .render_brief_data =
+        (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_misc_render_brief_data,
+    .render_error = (iButtonProtocolGroupRenderFunc)ibutton_protocol_group_misc_render_error,
+
+    .is_valid = (iButtonProtocolGroupIsValidFunc)ibutton_protocol_group_misc_is_valid,
+    .get_editable_data =
+        (iButtonProtocolGroupGetDataFunc)ibutton_protocol_group_misc_get_editable_data,
+    .apply_edits = (iButtonProtocolGroupApplyFunc)ibutton_protocol_group_misc_apply_edits,
+};
diff --git a/lib/one_wire/ibutton/protocols/misc/protocol_group_misc.h b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc.h
new file mode 100644
index 0000000000..7fde6e7376
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc.h
@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../protocol_group_base.h"
+
+extern const iButtonProtocolGroupBase ibutton_protocol_group_misc;
diff --git a/lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.c b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.c
new file mode 100644
index 0000000000..09ae0bdc7c
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.c
@@ -0,0 +1,10 @@
+#include "protocol_group_misc_defs.h"
+
+#include "protocol_cyfral.h"
+#include "protocol_metakom.h"
+
+const ProtocolBase* ibutton_protocols_misc[] = {
+    [iButtonProtocolMiscCyfral] = &ibutton_protocol_misc_cyfral,
+    [iButtonProtocolMiscMetakom] = &ibutton_protocol_misc_metakom,
+    /* Add new misc protocols here */
+};
diff --git a/lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.h b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.h
new file mode 100644
index 0000000000..0a7f92847e
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_group_misc_defs.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <toolbox/protocols/protocol.h>
+
+typedef enum {
+    iButtonProtocolMiscCyfral,
+    iButtonProtocolMiscMetakom,
+    iButtonProtocolMiscMax,
+} iButtonProtocolMisc;
+
+extern const ProtocolBase* ibutton_protocols_misc[];
diff --git a/lib/one_wire/ibutton/protocols/protocol_metakom.c b/lib/one_wire/ibutton/protocols/misc/protocol_metakom.c
similarity index 96%
rename from lib/one_wire/ibutton/protocols/protocol_metakom.c
rename to lib/one_wire/ibutton/protocols/misc/protocol_metakom.c
index ff65c6678f..a2bd2cf7ca 100644
--- a/lib/one_wire/ibutton/protocols/protocol_metakom.c
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_metakom.c
@@ -1,5 +1,6 @@
 #include <furi.h>
 #include <furi_hal.h>
+
 #include "protocol_metakom.h"
 
 #define METAKOM_DATA_SIZE sizeof(uint32_t)
@@ -300,7 +301,13 @@ static LevelDuration protocol_metakom_encoder_yield(ProtocolMetakom* proto) {
     return result;
 }
 
-const ProtocolBase protocol_metakom = {
+static void protocol_metakom_render_brief_data(ProtocolMetakom* proto, FuriString* result) {
+    for(size_t i = 0; i < METAKOM_DATA_SIZE; ++i) {
+        furi_string_cat_printf(result, "%02X ", ((uint8_t*)&proto->data)[i]);
+    }
+}
+
+const ProtocolBase ibutton_protocol_misc_metakom = {
     .name = "Metakom",
     .manufacturer = "Metakom",
     .data_size = METAKOM_DATA_SIZE,
@@ -317,4 +324,5 @@ const ProtocolBase protocol_metakom = {
             .start = (ProtocolEncoderStart)protocol_metakom_encoder_start,
             .yield = (ProtocolEncoderYield)protocol_metakom_encoder_yield,
         },
+    .render_brief_data = (ProtocolRenderData)protocol_metakom_render_brief_data,
 };
diff --git a/lib/one_wire/ibutton/protocols/misc/protocol_metakom.h b/lib/one_wire/ibutton/protocols/misc/protocol_metakom.h
new file mode 100644
index 0000000000..317619e3fb
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/misc/protocol_metakom.h
@@ -0,0 +1,4 @@
+#pragma once
+#include "toolbox/protocols/protocol.h"
+
+extern const ProtocolBase ibutton_protocol_misc_metakom;
diff --git a/lib/one_wire/ibutton/protocols/protocol_common.h b/lib/one_wire/ibutton/protocols/protocol_common.h
new file mode 100644
index 0000000000..5383158e46
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/protocol_common.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef int32_t iButtonProtocolId;
+
+enum {
+    iButtonProtocolIdInvalid = -1,
+};
+
+typedef enum {
+    iButtonProtocolFeatureExtData = (1U << 0),
+    iButtonProtocolFeatureWriteBlank = (1U << 1),
+    iButtonProtocolFeatureWriteCopy = (1U << 2),
+} iButtonProtocolFeature;
+
+typedef struct {
+    uint8_t* ptr;
+    size_t size;
+} iButtonEditableData;
diff --git a/lib/one_wire/ibutton/protocols/protocol_common_i.h b/lib/one_wire/ibutton/protocols/protocol_common_i.h
new file mode 100644
index 0000000000..b80c92887f
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/protocol_common_i.h
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "protocol_common.h"
+
+typedef void iButtonProtocolData;
+typedef int32_t iButtonProtocolLocalId;
diff --git a/lib/one_wire/ibutton/protocols/protocol_cyfral.h b/lib/one_wire/ibutton/protocols/protocol_cyfral.h
deleted file mode 100644
index 97a98e485e..0000000000
--- a/lib/one_wire/ibutton/protocols/protocol_cyfral.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-#include "toolbox/protocols/protocol.h"
-
-extern const ProtocolBase protocol_cyfral;
\ No newline at end of file
diff --git a/lib/one_wire/ibutton/protocols/protocol_group_base.h b/lib/one_wire/ibutton/protocols/protocol_group_base.h
new file mode 100644
index 0000000000..c8fec70fe7
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/protocol_group_base.h
@@ -0,0 +1,104 @@
+#pragma once
+
+#include <stdbool.h>
+#include <flipper_format.h>
+
+#include "protocol_common_i.h"
+
+typedef void iButtonProtocolGroupData;
+typedef int32_t iButtonProtocolGroupId;
+
+typedef iButtonProtocolGroupData* (*iButtonProtocolGroupAllocFunc)(void);
+
+typedef void (*iButtonProtocolGroupFreeFunc)(iButtonProtocolGroupData*);
+
+typedef void (*iButtonProtocolGroupRenderFunc)(
+    iButtonProtocolGroupData*,
+    const iButtonProtocolData*,
+    iButtonProtocolLocalId,
+    FuriString*);
+
+typedef bool (*iButtonProtocolGroupIsValidFunc)(
+    iButtonProtocolGroupData*,
+    const iButtonProtocolData*,
+    iButtonProtocolLocalId);
+
+typedef void (*iButtonProtocolGroupGetDataFunc)(
+    iButtonProtocolGroupData*,
+    iButtonProtocolData*,
+    iButtonProtocolLocalId,
+    iButtonEditableData*);
+
+typedef void (*iButtonProtocolGroupApplyFunc)(
+    iButtonProtocolGroupData*,
+    iButtonProtocolData*,
+    iButtonProtocolLocalId);
+
+typedef size_t (*iButtonProtocolGropuGetSizeFunc)(iButtonProtocolGroupData*);
+
+typedef uint32_t (
+    *iButtonProtocolGroupGetFeaturesFunc)(iButtonProtocolGroupData*, iButtonProtocolLocalId);
+
+typedef const char* (
+    *iButtonProtocolGroupGetStringFunc)(iButtonProtocolGroupData*, iButtonProtocolLocalId);
+
+typedef bool (*iButtonProtocolGroupGetIdFunc)(
+    iButtonProtocolGroupData*,
+    iButtonProtocolLocalId*,
+    const char*);
+
+typedef bool (*iButtonProtocolGroupReadFunc)(
+    iButtonProtocolGroupData*,
+    iButtonProtocolData*,
+    iButtonProtocolLocalId*);
+
+typedef bool (*iButtonProtocolGroupWriteFunc)(
+    iButtonProtocolGroupData*,
+    iButtonProtocolData*,
+    iButtonProtocolLocalId);
+
+typedef bool (*iButtonProtocolGroupSaveFunc)(
+    iButtonProtocolGroupData*,
+    const iButtonProtocolData*,
+    iButtonProtocolLocalId,
+    FlipperFormat*);
+
+typedef bool (*iButtonProtocolGroupLoadFunc)(
+    iButtonProtocolGroupData*,
+    iButtonProtocolData*,
+    iButtonProtocolLocalId,
+    uint32_t,
+    FlipperFormat*);
+
+typedef struct {
+    const uint32_t protocol_count;
+
+    iButtonProtocolGroupAllocFunc alloc;
+    iButtonProtocolGroupFreeFunc free;
+
+    iButtonProtocolGropuGetSizeFunc get_max_data_size;
+    iButtonProtocolGroupGetIdFunc get_id_by_name;
+    iButtonProtocolGroupGetFeaturesFunc get_features;
+
+    iButtonProtocolGroupGetStringFunc get_manufacturer;
+    iButtonProtocolGroupGetStringFunc get_name;
+
+    iButtonProtocolGroupReadFunc read;
+    iButtonProtocolGroupWriteFunc write_blank;
+    iButtonProtocolGroupWriteFunc write_copy;
+
+    iButtonProtocolGroupApplyFunc emulate_start;
+    iButtonProtocolGroupApplyFunc emulate_stop;
+
+    iButtonProtocolGroupSaveFunc save;
+    iButtonProtocolGroupLoadFunc load;
+
+    iButtonProtocolGroupRenderFunc render_data;
+    iButtonProtocolGroupRenderFunc render_brief_data;
+    iButtonProtocolGroupRenderFunc render_error;
+
+    iButtonProtocolGroupIsValidFunc is_valid;
+    iButtonProtocolGroupGetDataFunc get_editable_data;
+
+    iButtonProtocolGroupApplyFunc apply_edits;
+} iButtonProtocolGroupBase;
diff --git a/lib/one_wire/ibutton/protocols/protocol_group_defs.c b/lib/one_wire/ibutton/protocols/protocol_group_defs.c
new file mode 100644
index 0000000000..40a360f0eb
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/protocol_group_defs.c
@@ -0,0 +1,9 @@
+#include "protocol_group_defs.h"
+
+#include "dallas/protocol_group_dallas.h"
+#include "misc/protocol_group_misc.h"
+
+const iButtonProtocolGroupBase* ibutton_protocol_groups[] = {
+    [iButtonProtocolGroupDallas] = &ibutton_protocol_group_dallas,
+    [iButtonProtocolGroupMisc] = &ibutton_protocol_group_misc,
+};
diff --git a/lib/one_wire/ibutton/protocols/protocol_group_defs.h b/lib/one_wire/ibutton/protocols/protocol_group_defs.h
new file mode 100644
index 0000000000..2d41e3cb86
--- /dev/null
+++ b/lib/one_wire/ibutton/protocols/protocol_group_defs.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "protocol_group_base.h"
+
+typedef enum {
+    iButtonProtocolGroupDallas,
+    iButtonProtocolGroupMisc,
+    iButtonProtocolGroupMax
+} iButtonProtocolGroup;
+
+extern const iButtonProtocolGroupBase* ibutton_protocol_groups[];
diff --git a/lib/one_wire/ibutton/protocols/protocol_metakom.h b/lib/one_wire/ibutton/protocols/protocol_metakom.h
deleted file mode 100644
index 5e44a2a8ce..0000000000
--- a/lib/one_wire/ibutton/protocols/protocol_metakom.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#pragma once
-#include "toolbox/protocols/protocol.h"
-
-extern const ProtocolBase protocol_metakom;
\ No newline at end of file
diff --git a/lib/one_wire/one_wire_device.c b/lib/one_wire/one_wire_device.c
deleted file mode 100644
index d9b4955dbe..0000000000
--- a/lib/one_wire/one_wire_device.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stdlib.h>
-#include "maxim_crc.h"
-#include "one_wire_device.h"
-#include "one_wire_slave.h"
-#include "one_wire_slave_i.h"
-
-struct OneWireDevice {
-    uint8_t id_storage[8];
-    OneWireSlave* bus;
-};
-
-OneWireDevice* onewire_device_alloc(
-    uint8_t id_1,
-    uint8_t id_2,
-    uint8_t id_3,
-    uint8_t id_4,
-    uint8_t id_5,
-    uint8_t id_6,
-    uint8_t id_7,
-    uint8_t id_8) {
-    OneWireDevice* device = malloc(sizeof(OneWireDevice));
-    device->id_storage[0] = id_1;
-    device->id_storage[1] = id_2;
-    device->id_storage[2] = id_3;
-    device->id_storage[3] = id_4;
-    device->id_storage[4] = id_5;
-    device->id_storage[5] = id_6;
-    device->id_storage[6] = id_7;
-    device->id_storage[7] = id_8;
-    device->bus = NULL;
-
-    return device;
-}
-
-void onewire_device_free(OneWireDevice* device) {
-    if(device->bus != NULL) {
-        onewire_slave_detach(device->bus);
-    }
-
-    free(device);
-}
-
-void onewire_device_send_id(OneWireDevice* device) {
-    if(device->bus != NULL) {
-        onewire_slave_send(device->bus, device->id_storage, 8);
-    }
-}
-
-void onewire_device_attach(OneWireDevice* device, OneWireSlave* bus) {
-    device->bus = bus;
-}
-
-void onewire_device_detach(OneWireDevice* device) {
-    device->bus = NULL;
-}
-
-uint8_t* onewire_device_get_id_p(OneWireDevice* device) {
-    return device->id_storage;
-}
diff --git a/lib/one_wire/one_wire_device.h b/lib/one_wire/one_wire_device.h
deleted file mode 100644
index fc687c7bad..0000000000
--- a/lib/one_wire/one_wire_device.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * @file one_wire_device.h
- * 
- * 1-Wire slave library, device interface. Currently it can only emulate ID.
- */
-
-#pragma once
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct OneWireSlave OneWireSlave;
-typedef struct OneWireDevice OneWireDevice;
-
-/**
- * Allocate onewire device with ID
- * @param id_1 
- * @param id_2 
- * @param id_3 
- * @param id_4 
- * @param id_5 
- * @param id_6 
- * @param id_7 
- * @param id_8 
- * @return OneWireDevice* 
- */
-OneWireDevice* onewire_device_alloc(
-    uint8_t id_1,
-    uint8_t id_2,
-    uint8_t id_3,
-    uint8_t id_4,
-    uint8_t id_5,
-    uint8_t id_6,
-    uint8_t id_7,
-    uint8_t id_8);
-
-/**
- * Deallocate onewire device
- * @param device 
- */
-void onewire_device_free(OneWireDevice* device);
-
-/**
- * Send ID report, called from onewire slave
- * @param device 
- */
-void onewire_device_send_id(OneWireDevice* device);
-
-/**
- * Attach device to onewire slave bus
- * @param device 
- * @param bus 
- */
-void onewire_device_attach(OneWireDevice* device, OneWireSlave* bus);
-
-/**
- * Attach device from onewire slave bus
- * @param device 
- */
-void onewire_device_detach(OneWireDevice* device);
-
-/**
- * Get pointer to device id array
- * @param device 
- * @return uint8_t* 
- */
-uint8_t* onewire_device_get_id_p(OneWireDevice* device);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/lib/one_wire/one_wire_host.c b/lib/one_wire/one_wire_host.c
index f3d3d3c4dc..0a4a79f5cc 100644
--- a/lib/one_wire/one_wire_host.c
+++ b/lib/one_wire/one_wire_host.c
@@ -116,6 +116,12 @@ void onewire_host_write(OneWireHost* host, uint8_t value) {
     }
 }
 
+void onewire_host_write_bytes(OneWireHost* host, const uint8_t* buffer, uint16_t count) {
+    for(uint16_t i = 0; i < count; ++i) {
+        onewire_host_write(host, buffer[i]);
+    }
+}
+
 void onewire_host_skip(OneWireHost* host) {
     onewire_host_write(host, 0xCC);
 }
@@ -175,10 +181,10 @@ uint8_t onewire_host_search(OneWireHost* host, uint8_t* new_addr, OneWireHostSea
 
         // issue the search command
         switch(mode) {
-        case CONDITIONAL_SEARCH:
+        case OneWireHostSearchModeConditional:
             onewire_host_write(host, 0xEC);
             break;
-        case NORMAL_SEARCH:
+        case OneWireHostSearchModeNormal:
             onewire_host_write(host, 0xF0);
             break;
         }
diff --git a/lib/one_wire/one_wire_host.h b/lib/one_wire/one_wire_host.h
index 9c01abc114..dc469904dd 100644
--- a/lib/one_wire/one_wire_host.h
+++ b/lib/one_wire/one_wire_host.h
@@ -14,8 +14,8 @@ extern "C" {
 #endif
 
 typedef enum {
-    CONDITIONAL_SEARCH = 0, /**< Search for alarmed device */
-    NORMAL_SEARCH = 1, /**< Search all devices */
+    OneWireHostSearchModeConditional = 0, /**< Search for alarmed device */
+    OneWireHostSearchModeNormal = 1, /**< Search all devices */
 } OneWireHostSearchMode;
 
 typedef struct OneWireHost OneWireHost;
@@ -76,6 +76,14 @@ void onewire_host_write_bit(OneWireHost* host, bool value);
  */
 void onewire_host_write(OneWireHost* host, uint8_t value);
 
+/**
+ * Write many bytes
+ * @param host
+ * @param buffer
+ * @param count
+ */
+void onewire_host_write_bytes(OneWireHost* host, const uint8_t* buffer, uint16_t count);
+
 /**
  * Skip ROM command
  * @param host 
diff --git a/lib/one_wire/one_wire_slave.c b/lib/one_wire/one_wire_slave.c
index 4b54c4f99f..d1676cf3b8 100644
--- a/lib/one_wire/one_wire_slave.c
+++ b/lib/one_wire/one_wire_slave.c
@@ -1,37 +1,42 @@
 #include "one_wire_slave.h"
-#include "one_wire_slave_i.h"
-#include "one_wire_device.h"
+
 #include <furi.h>
 #include <furi_hal.h>
 
-#define OWS_RESET_MIN 270
-#define OWS_RESET_MAX 960
-#define OWS_PRESENCE_TIMEOUT 20
-#define OWS_PRESENCE_MIN 100
-#define OWS_PRESENCE_MAX 480
-#define OWS_MSG_HIGH_TIMEOUT 15000
-#define OWS_SLOT_MAX 135
-#define OWS_READ_MIN 20
-#define OWS_READ_MAX 60
-#define OWS_WRITE_ZERO 30
+#define ONEWIRE_TRSTL_MIN 270 /* Minimum Reset Low time */
+#define ONEWIRE_TRSTL_MAX 1200 /* Maximum Reset Low time */
+
+#define ONEWIRE_TPDH_TYP 20 /* Typical Presence Detect High time */
+#define ONEWIRE_TPDL_MIN 100 /* Minimum Presence Detect Low time */
+#define ONEWIRE_TPDL_MAX 480 /* Maximum Presence Detect Low time */
+
+#define ONEWIRE_TSLOT_MIN 60 /* Minimum Read/Write Slot time */
+#define ONEWIRE_TSLOT_MAX 135 /* Maximum Read/Write Slot time */
+
+#define ONEWIRE_TW1L_MAX 20 /* Maximum Master Write 1 time */
+#define ONEWIRE_TRL_TMSR_MAX 30 /* Maximum Master Read Low + Read Sample time */
+
+#define ONEWIRE_TH_TIMEOUT 15000 /* Maximum time before general timeout */
 
 typedef enum {
-    NO_ERROR = 0,
-    VERY_LONG_RESET,
-    VERY_SHORT_RESET,
-    PRESENCE_LOW_ON_LINE,
-    AWAIT_TIMESLOT_TIMEOUT_HIGH,
-    INCORRECT_ONEWIRE_CMD,
-    FIRST_BIT_OF_BYTE_TIMEOUT,
-    RESET_IN_PROGRESS
+    OneWireSlaveErrorNone = 0,
+    OneWireSlaveErrorResetInProgress,
+    OneWireSlaveErrorPresenceConflict,
+    OneWireSlaveErrorInvalidCommand,
+    OneWireSlaveErrorTimeout,
 } OneWireSlaveError;
 
 struct OneWireSlave {
     const GpioPin* gpio_pin;
     OneWireSlaveError error;
-    OneWireDevice* device;
-    OneWireSlaveResultCallback result_cb;
-    void* result_cb_ctx;
+
+    OneWireSlaveResetCallback reset_callback;
+    OneWireSlaveCommandCallback command_callback;
+    OneWireSlaveResultCallback result_callback;
+
+    void* reset_callback_context;
+    void* result_callback_context;
+    void* command_callback_context;
 };
 
 /*********************** PRIVATE ***********************/
@@ -55,180 +60,94 @@ static uint32_t
 }
 
 static bool onewire_slave_show_presence(OneWireSlave* bus) {
+    // wait until the bus is high (might return immediately)
+    onewire_slave_wait_while_gpio_is(bus, ONEWIRE_TRSTL_MAX, false);
     // wait while master delay presence check
-    onewire_slave_wait_while_gpio_is(bus, OWS_PRESENCE_TIMEOUT, true);
+    furi_delay_us(ONEWIRE_TPDH_TYP);
 
     // show presence
     furi_hal_gpio_write(bus->gpio_pin, false);
-    furi_delay_us(OWS_PRESENCE_MIN);
+    furi_delay_us(ONEWIRE_TPDL_MIN);
     furi_hal_gpio_write(bus->gpio_pin, true);
 
     // somebody also can show presence
-    const uint32_t wait_low_time = OWS_PRESENCE_MAX - OWS_PRESENCE_MIN;
+    const uint32_t wait_low_time = ONEWIRE_TPDL_MAX - ONEWIRE_TPDL_MIN;
 
     // so we will wait
     if(onewire_slave_wait_while_gpio_is(bus, wait_low_time, false) == 0) {
-        bus->error = PRESENCE_LOW_ON_LINE;
+        bus->error = OneWireSlaveErrorPresenceConflict;
         return false;
     }
 
     return true;
 }
 
-static bool onewire_slave_receive_bit(OneWireSlave* bus) {
-    // wait while bus is low
-    uint32_t time = OWS_SLOT_MAX;
-    time = onewire_slave_wait_while_gpio_is(bus, time, false);
-    if(time == 0) {
-        bus->error = RESET_IN_PROGRESS;
-        return false;
-    }
-
-    // wait while bus is high
-    time = OWS_MSG_HIGH_TIMEOUT;
-    time = onewire_slave_wait_while_gpio_is(bus, time, true);
-    if(time == 0) {
-        bus->error = AWAIT_TIMESLOT_TIMEOUT_HIGH;
-        return false;
-    }
-
-    // wait a time of zero
-    time = OWS_READ_MIN;
-    time = onewire_slave_wait_while_gpio_is(bus, time, false);
-
-    return (time > 0);
-}
-
-static bool onewire_slave_send_bit(OneWireSlave* bus, bool value) {
-    const bool write_zero = !value;
-
-    // wait while bus is low
-    uint32_t time = OWS_SLOT_MAX;
-    time = onewire_slave_wait_while_gpio_is(bus, time, false);
-    if(time == 0) {
-        bus->error = RESET_IN_PROGRESS;
-        return false;
-    }
-
-    // wait while bus is high
-    time = OWS_MSG_HIGH_TIMEOUT;
-    time = onewire_slave_wait_while_gpio_is(bus, time, true);
-    if(time == 0) {
-        bus->error = AWAIT_TIMESLOT_TIMEOUT_HIGH;
-        return false;
-    }
-
-    // choose write time
-    if(write_zero) {
-        furi_hal_gpio_write(bus->gpio_pin, false);
-        time = OWS_WRITE_ZERO;
-    } else {
-        time = OWS_READ_MAX;
-    }
-
-    // hold line for ZERO or ONE time
-    furi_delay_us(time);
-    furi_hal_gpio_write(bus->gpio_pin, true);
-
-    return true;
-}
-
-static void onewire_slave_cmd_search_rom(OneWireSlave* bus) {
-    const uint8_t key_bytes = 8;
-    uint8_t* key = onewire_device_get_id_p(bus->device);
-
-    for(uint8_t i = 0; i < key_bytes; i++) {
-        uint8_t key_byte = key[i];
+static inline bool onewire_slave_receive_and_process_command(OneWireSlave* bus) {
+    /* Reset condition detected, send a presence pulse and reset protocol state */
+    if(bus->error == OneWireSlaveErrorResetInProgress) {
+        if(onewire_slave_show_presence(bus)) {
+            bus->error = OneWireSlaveErrorNone;
 
-        for(uint8_t j = 0; j < 8; j++) {
-            bool bit = (key_byte >> j) & 0x01;
+            if(bus->reset_callback != NULL) {
+                bus->reset_callback(bus->reset_callback_context);
+            }
 
-            if(!onewire_slave_send_bit(bus, bit)) return;
-            if(!onewire_slave_send_bit(bus, !bit)) return;
+            return true;
+        }
 
-            onewire_slave_receive_bit(bus);
-            if(bus->error != NO_ERROR) return;
+    } else if(bus->error == OneWireSlaveErrorNone) {
+        uint8_t command;
+        if(!onewire_slave_receive(bus, &command, 1)) {
+            /* Upon failure, request an additional iteration to
+               choose the appropriate action by checking bus->error */
+            return true;
+        } else if(bus->command_callback) {
+            return bus->command_callback(command, bus->command_callback_context);
+        } else {
+            bus->error = OneWireSlaveErrorInvalidCommand;
         }
     }
-}
-
-static bool onewire_slave_receive_and_process_cmd(OneWireSlave* bus) {
-    uint8_t cmd;
-    onewire_slave_receive(bus, &cmd, 1);
 
-    if(bus->error == RESET_IN_PROGRESS)
-        return true;
-    else if(bus->error != NO_ERROR)
-        return false;
-
-    switch(cmd) {
-    case 0xF0:
-        // SEARCH ROM
-        onewire_slave_cmd_search_rom(bus);
-        return true;
-
-    case 0x0F:
-    case 0x33:
-        // READ ROM
-        onewire_device_send_id(bus->device);
-        return true;
-
-    default: // Unknown command
-        bus->error = INCORRECT_ONEWIRE_CMD;
-        return false;
-    }
+    return false;
 }
 
-static bool onewire_slave_bus_start(OneWireSlave* bus) {
-    bool result = true;
+static inline bool onewire_slave_bus_start(OneWireSlave* bus) {
+    FURI_CRITICAL_ENTER();
+    furi_hal_gpio_init(bus->gpio_pin, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
 
-    if(bus->device == NULL) {
-        result = false;
-    } else {
-        FURI_CRITICAL_ENTER();
-        furi_hal_gpio_init(bus->gpio_pin, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
-        bus->error = NO_ERROR;
+    /* Start in Reset state in order to send a presence pulse immediately */
+    bus->error = OneWireSlaveErrorResetInProgress;
 
-        if(onewire_slave_show_presence(bus)) {
-            // TODO think about multiple command cycles
-            onewire_slave_receive_and_process_cmd(bus);
-            result = (bus->error == NO_ERROR || bus->error == INCORRECT_ONEWIRE_CMD);
+    while(onewire_slave_receive_and_process_command(bus))
+        ;
 
-        } else {
-            result = false;
-        }
+    const bool result = (bus->error == OneWireSlaveErrorNone);
 
-        furi_hal_gpio_init(bus->gpio_pin, GpioModeInterruptRiseFall, GpioPullNo, GpioSpeedLow);
-        FURI_CRITICAL_EXIT();
-    }
+    furi_hal_gpio_init(bus->gpio_pin, GpioModeInterruptRiseFall, GpioPullNo, GpioSpeedLow);
+    FURI_CRITICAL_EXIT();
 
     return result;
 }
 
-static void exti_cb(void* context) {
+static void onewire_slave_exti_callback(void* context) {
     OneWireSlave* bus = context;
 
-    volatile bool input_state = furi_hal_gpio_read(bus->gpio_pin);
+    const volatile bool input_state = furi_hal_gpio_read(bus->gpio_pin);
     static uint32_t pulse_start = 0;
 
     if(input_state) {
-        uint32_t pulse_length =
+        const uint32_t pulse_length =
             (DWT->CYCCNT - pulse_start) / furi_hal_cortex_instructions_per_microsecond();
-        if(pulse_length >= OWS_RESET_MIN) {
-            if(pulse_length <= OWS_RESET_MAX) {
-                // reset cycle ok
-                bool result = onewire_slave_bus_start(bus);
-                if(result && bus->result_cb != NULL) {
-                    bus->result_cb(bus->result_cb_ctx);
-                }
-            } else {
-                bus->error = VERY_LONG_RESET;
+
+        if((pulse_length >= ONEWIRE_TRSTL_MIN) && pulse_length <= (ONEWIRE_TRSTL_MAX)) {
+            const bool result = onewire_slave_bus_start(bus);
+
+            if(result && bus->result_callback != NULL) {
+                bus->result_callback(bus->result_callback_context);
             }
-        } else {
-            bus->error = VERY_SHORT_RESET;
         }
+
     } else {
-        //FALL event
         pulse_start = DWT->CYCCNT;
     }
 };
@@ -237,11 +156,10 @@ static void exti_cb(void* context) {
 
 OneWireSlave* onewire_slave_alloc(const GpioPin* gpio_pin) {
     OneWireSlave* bus = malloc(sizeof(OneWireSlave));
+
     bus->gpio_pin = gpio_pin;
-    bus->error = NO_ERROR;
-    bus->device = NULL;
-    bus->result_cb = NULL;
-    bus->result_cb_ctx = NULL;
+    bus->error = OneWireSlaveErrorNone;
+
     return bus;
 }
 
@@ -251,7 +169,7 @@ void onewire_slave_free(OneWireSlave* bus) {
 }
 
 void onewire_slave_start(OneWireSlave* bus) {
-    furi_hal_gpio_add_int_callback(bus->gpio_pin, exti_cb, bus);
+    furi_hal_gpio_add_int_callback(bus->gpio_pin, onewire_slave_exti_callback, bus);
     furi_hal_gpio_write(bus->gpio_pin, true);
     furi_hal_gpio_init(bus->gpio_pin, GpioModeInterruptRiseFall, GpioPullNo, GpioSpeedLow);
 }
@@ -262,41 +180,98 @@ void onewire_slave_stop(OneWireSlave* bus) {
     furi_hal_gpio_remove_int_callback(bus->gpio_pin);
 }
 
-void onewire_slave_attach(OneWireSlave* bus, OneWireDevice* device) {
-    bus->device = device;
-    onewire_device_attach(device, bus);
+void onewire_slave_set_reset_callback(
+    OneWireSlave* bus,
+    OneWireSlaveResetCallback callback,
+    void* context) {
+    bus->reset_callback = callback;
+    bus->reset_callback_context = context;
 }
 
-void onewire_slave_detach(OneWireSlave* bus) {
-    if(bus->device != NULL) {
-        onewire_device_detach(bus->device);
-    }
-    bus->device = NULL;
+void onewire_slave_set_command_callback(
+    OneWireSlave* bus,
+    OneWireSlaveCommandCallback callback,
+    void* context) {
+    bus->command_callback = callback;
+    bus->command_callback_context = context;
 }
 
 void onewire_slave_set_result_callback(
     OneWireSlave* bus,
     OneWireSlaveResultCallback result_cb,
     void* context) {
-    bus->result_cb = result_cb;
-    bus->result_cb_ctx = context;
+    bus->result_callback = result_cb;
+    bus->result_callback_context = context;
+}
+
+bool onewire_slave_receive_bit(OneWireSlave* bus) {
+    // wait while bus is low
+    uint32_t time = ONEWIRE_TSLOT_MAX;
+    time = onewire_slave_wait_while_gpio_is(bus, time, false);
+    if(time == 0) {
+        bus->error = OneWireSlaveErrorResetInProgress;
+        return false;
+    }
+
+    // wait while bus is high
+    time = ONEWIRE_TH_TIMEOUT;
+    time = onewire_slave_wait_while_gpio_is(bus, time, true);
+    if(time == 0) {
+        bus->error = OneWireSlaveErrorTimeout;
+        return false;
+    }
+
+    // wait a time of zero
+    time = ONEWIRE_TW1L_MAX;
+    time = onewire_slave_wait_while_gpio_is(bus, time, false);
+
+    return (time > 0);
 }
 
-bool onewire_slave_send(OneWireSlave* bus, const uint8_t* address, const uint8_t data_length) {
-    uint8_t bytes_sent = 0;
+bool onewire_slave_send_bit(OneWireSlave* bus, bool value) {
+    // wait while bus is low
+    uint32_t time = ONEWIRE_TSLOT_MAX;
+    time = onewire_slave_wait_while_gpio_is(bus, time, false);
+    if(time == 0) {
+        bus->error = OneWireSlaveErrorResetInProgress;
+        return false;
+    }
+
+    // wait while bus is high
+    time = ONEWIRE_TH_TIMEOUT;
+    time = onewire_slave_wait_while_gpio_is(bus, time, true);
+    if(time == 0) {
+        bus->error = OneWireSlaveErrorTimeout;
+        return false;
+    }
+
+    // choose write time
+    if(!value) {
+        furi_hal_gpio_write(bus->gpio_pin, false);
+        time = ONEWIRE_TRL_TMSR_MAX;
+    } else {
+        time = ONEWIRE_TSLOT_MIN;
+    }
+
+    // hold line for ZERO or ONE time
+    furi_delay_us(time);
+    furi_hal_gpio_write(bus->gpio_pin, true);
+
+    return true;
+}
 
+bool onewire_slave_send(OneWireSlave* bus, const uint8_t* data, size_t data_size) {
     furi_hal_gpio_write(bus->gpio_pin, true);
 
+    size_t bytes_sent = 0;
+
     // bytes loop
-    for(; bytes_sent < data_length; ++bytes_sent) {
-        const uint8_t data_byte = address[bytes_sent];
+    for(; bytes_sent < data_size; ++bytes_sent) {
+        const uint8_t data_byte = data[bytes_sent];
 
         // bit loop
         for(uint8_t bit_mask = 0x01; bit_mask != 0; bit_mask <<= 1) {
             if(!onewire_slave_send_bit(bus, bit_mask & data_byte)) {
-                // if we cannot send first bit
-                if((bit_mask == 0x01) && (bus->error == AWAIT_TIMESLOT_TIMEOUT_HIGH))
-                    bus->error = FIRST_BIT_OF_BYTE_TIMEOUT;
                 return false;
             }
         }
@@ -304,19 +279,25 @@ bool onewire_slave_send(OneWireSlave* bus, const uint8_t* address, const uint8_t
     return true;
 }
 
-bool onewire_slave_receive(OneWireSlave* bus, uint8_t* data, const uint8_t data_length) {
-    uint8_t bytes_received = 0;
-
+bool onewire_slave_receive(OneWireSlave* bus, uint8_t* data, size_t data_size) {
     furi_hal_gpio_write(bus->gpio_pin, true);
 
-    for(; bytes_received < data_length; ++bytes_received) {
+    size_t bytes_received = 0;
+
+    for(; bytes_received < data_size; ++bytes_received) {
         uint8_t value = 0;
 
         for(uint8_t bit_mask = 0x01; bit_mask != 0; bit_mask <<= 1) {
-            if(onewire_slave_receive_bit(bus)) value |= bit_mask;
+            if(onewire_slave_receive_bit(bus)) {
+                value |= bit_mask;
+            }
+
+            if(bus->error != OneWireSlaveErrorNone) {
+                return false;
+            }
         }
 
         data[bytes_received] = value;
     }
-    return (bytes_received != data_length);
+    return true;
 }
diff --git a/lib/one_wire/one_wire_slave.h b/lib/one_wire/one_wire_slave.h
index 2e5db3a1c2..914cd9335e 100644
--- a/lib/one_wire/one_wire_slave.h
+++ b/lib/one_wire/one_wire_slave.h
@@ -1,12 +1,14 @@
 /**
  * @file one_wire_slave.h
  * 
- * 1-Wire slave library. Currently it can only emulate ID.
+ * 1-Wire slave library.
  */
 
 #pragma once
+#include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
+
 #include <furi_hal_gpio.h>
 
 #ifdef __cplusplus
@@ -15,7 +17,10 @@ extern "C" {
 
 typedef struct OneWireDevice OneWireDevice;
 typedef struct OneWireSlave OneWireSlave;
+
+typedef void (*OneWireSlaveResetCallback)(void* context);
 typedef void (*OneWireSlaveResultCallback)(void* context);
+typedef bool (*OneWireSlaveCommandCallback)(uint8_t command, void* context);
 
 /**
  * Allocate onewire slave
@@ -43,17 +48,54 @@ void onewire_slave_start(OneWireSlave* bus);
 void onewire_slave_stop(OneWireSlave* bus);
 
 /**
- * Attach device for emulation
- * @param bus 
- * @param device 
+ * TODO: description comment
  */
-void onewire_slave_attach(OneWireSlave* bus, OneWireDevice* device);
+bool onewire_slave_receive_bit(OneWireSlave* bus);
 
 /**
- * Detach device from bus
- * @param bus 
+ * TODO: description comment
+ */
+bool onewire_slave_send_bit(OneWireSlave* bus, bool value);
+
+/**
+ * Send data
+ * @param bus
+ * @param data
+ * @param data_size
+ * @return bool
+ */
+bool onewire_slave_send(OneWireSlave* bus, const uint8_t* data, size_t data_size);
+
+/**
+ * Receive data
+ * @param bus
+ * @param data
+ * @param data_size
+ * @return bool
  */
-void onewire_slave_detach(OneWireSlave* bus);
+bool onewire_slave_receive(OneWireSlave* bus, uint8_t* data, size_t data_size);
+
+/**
+ * Set a callback to be called on each reset
+ * @param bus
+ * @param callback
+ * @param context
+ */
+void onewire_slave_set_reset_callback(
+    OneWireSlave* bus,
+    OneWireSlaveResetCallback callback,
+    void* context);
+
+/**
+ * Set a callback to be called on each command
+ * @param bus
+ * @param callback
+ * @param context
+ */
+void onewire_slave_set_command_callback(
+    OneWireSlave* bus,
+    OneWireSlaveCommandCallback callback,
+    void* context);
 
 /**
  * Set a callback to report emulation success
diff --git a/lib/one_wire/one_wire_slave_i.h b/lib/one_wire/one_wire_slave_i.h
deleted file mode 100644
index 55e0762e44..0000000000
--- a/lib/one_wire/one_wire_slave_i.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * @file one_wire_slave_i.h
- * 
- * 1-Wire slave library, internal functions
- */
-
-#pragma once
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct OneWireDevice OneWireDevice;
-typedef struct OneWireSlave OneWireSlave;
-
-/**
- * Send data, called from emulated device
- * @param bus 
- * @param address 
- * @param data_length 
- * @return bool 
- */
-bool onewire_slave_send(OneWireSlave* bus, const uint8_t* address, const uint8_t data_length);
-
-/**
- * Receive data, called from emulated device
- * @param bus 
- * @param data 
- * @param data_length 
- * @return bool 
- */
-bool onewire_slave_receive(OneWireSlave* bus, uint8_t* data, const uint8_t data_length);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/lib/subghz/blocks/generic.c b/lib/subghz/blocks/generic.c
index 54a401e050..331606fe5c 100644
--- a/lib/subghz/blocks/generic.c
+++ b/lib/subghz/blocks/generic.c
@@ -20,12 +20,12 @@ void subghz_block_generic_get_preset_name(const char* preset_name, FuriString* p
     furi_string_set(preset_str, preset_name_temp);
 }
 
-bool subghz_block_generic_serialize(
+SubGhzProtocolStatus subghz_block_generic_serialize(
     SubGhzBlockGeneric* instance,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(instance);
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     do {
@@ -33,11 +33,13 @@ bool subghz_block_generic_serialize(
         if(!flipper_format_write_header_cstr(
                flipper_format, SUBGHZ_KEY_FILE_TYPE, SUBGHZ_KEY_FILE_VERSION)) {
             FURI_LOG_E(TAG, "Unable to add header");
+            res = SubGhzProtocolStatusErrorParserHeader;
             break;
         }
 
         if(!flipper_format_write_uint32(flipper_format, "Frequency", &preset->frequency, 1)) {
             FURI_LOG_E(TAG, "Unable to add Frequency");
+            res = SubGhzProtocolStatusErrorParserFrequency;
             break;
         }
 
@@ -45,27 +47,32 @@ bool subghz_block_generic_serialize(
         if(!flipper_format_write_string_cstr(
                flipper_format, "Preset", furi_string_get_cstr(temp_str))) {
             FURI_LOG_E(TAG, "Unable to add Preset");
+            res = SubGhzProtocolStatusErrorParserPreset;
             break;
         }
         if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
             if(!flipper_format_write_string_cstr(
                    flipper_format, "Custom_preset_module", "CC1101")) {
                 FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
                 break;
             }
             if(!flipper_format_write_hex(
                    flipper_format, "Custom_preset_data", preset->data, preset->data_size)) {
                 FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
                 break;
             }
         }
         if(!flipper_format_write_string_cstr(flipper_format, "Protocol", instance->protocol_name)) {
             FURI_LOG_E(TAG, "Unable to add Protocol");
+            res = SubGhzProtocolStatusErrorParserProtocolName;
             break;
         }
         uint32_t temp = instance->data_count_bit;
         if(!flipper_format_write_uint32(flipper_format, "Bit", &temp, 1)) {
             FURI_LOG_E(TAG, "Unable to add Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
 
@@ -76,6 +83,7 @@ bool subghz_block_generic_serialize(
 
         if(!flipper_format_write_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to add Key");
+            res = SubGhzProtocolStatusErrorParserKey;
             break;
         }
 
@@ -88,15 +96,16 @@ bool subghz_block_generic_serialize(
                 break;
             }
         }
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
     furi_string_free(temp_str);
     return res;
 }
 
-bool subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperFormat* flipper_format) {
     furi_assert(instance);
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     uint32_t temp_data = 0;
@@ -104,10 +113,12 @@ bool subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperForma
     do {
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
         instance->data_count_bit = (uint16_t)temp_data;
@@ -115,16 +126,36 @@ bool subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperForma
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Missing Key");
+            res = SubGhzProtocolStatusErrorParserKey;
             break;
         }
         for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
             instance->data = instance->data << 8 | key_data[i];
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(0);
 
     furi_string_free(temp_str);
 
     return res;
 }
+
+SubGhzProtocolStatus subghz_block_generic_deserialize_check_count_bit(
+    SubGhzBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    uint16_t count_bit) {
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(instance, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->data_count_bit != count_bit) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
\ No newline at end of file
diff --git a/lib/subghz/blocks/generic.h b/lib/subghz/blocks/generic.h
index e69de8b4f9..10e7b63fab 100644
--- a/lib/subghz/blocks/generic.h
+++ b/lib/subghz/blocks/generic.h
@@ -39,9 +39,9 @@ void subghz_block_generic_get_preset_name(const char* preset_name, FuriString* p
  * @param instance Pointer to a SubGhzBlockGeneric instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return Status Error
  */
-bool subghz_block_generic_serialize(
+SubGhzProtocolStatus subghz_block_generic_serialize(
     SubGhzBlockGeneric* instance,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -50,9 +50,22 @@ bool subghz_block_generic_serialize(
  * Deserialize data SubGhzBlockGeneric.
  * @param instance Pointer to a SubGhzBlockGeneric instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return Status Error
  */
-bool subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperFormat* flipper_format);
+
+/**
+ * Deserialize data SubGhzBlockGeneric.
+ * @param instance Pointer to a SubGhzBlockGeneric instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param count_bit Count bit protocol
+ * @return Status Error
+ */
+SubGhzProtocolStatus subghz_block_generic_deserialize_check_count_bit(
+    SubGhzBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    uint16_t count_bit);
 
 #ifdef __cplusplus
 }
diff --git a/lib/subghz/protocols/alutech_at_4n.c b/lib/subghz/protocols/alutech_at_4n.c
index 15887cd6d9..7b1bd5e766 100644
--- a/lib/subghz/protocols/alutech_at_4n.c
+++ b/lib/subghz/protocols/alutech_at_4n.c
@@ -320,7 +320,8 @@ bool subghz_protocol_alutech_at_4n_create_data(
     instance->generic.data_count_bit = 72;
     bool res = subghz_protocol_alutech_at_4n_gen_data(instance, btn);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -499,14 +500,15 @@ static bool subghz_protocol_encoder_alutech_at_4n_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_alutech_at_4n_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_alutech_at_4n_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderAlutech_at_4n* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -540,7 +542,7 @@ bool subghz_protocol_encoder_alutech_at_4n_deserialize(
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -740,46 +742,46 @@ uint8_t subghz_protocol_decoder_alutech_at_4n_get_hash_data(void* context) {
     return (uint8_t)instance->crc;
 }
 
-bool subghz_protocol_decoder_alutech_at_4n_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_alutech_at_4n_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderAlutech_at_4n* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
-    if(res && !flipper_format_write_uint32(flipper_format, "CRC", &instance->crc, 1)) {
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "CRC", &instance->crc, 1)) {
         FURI_LOG_E(TAG, "Unable to add CRC");
-        res = false;
+        res = SubGhzProtocolStatusErrorParserOthers;
     }
     return res;
-
-    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_alutech_at_4n_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_alutech_at_4n_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderAlutech_at_4n* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_alutech_at_4n_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_alutech_at_4n_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "CRC", (uint32_t*)&instance->crc, 1)) {
             FURI_LOG_E(TAG, "Missing CRC");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/alutech_at_4n.h b/lib/subghz/protocols/alutech_at_4n.h
index b0ac056dda..89adbb5c63 100644
--- a/lib/subghz/protocols/alutech_at_4n.h
+++ b/lib/subghz/protocols/alutech_at_4n.h
@@ -55,9 +55,8 @@ bool subghz_protocol_alutech_at_4n_create_data(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_alutech_at_4n_deserialize(
-    void* context,
-    FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_alutech_at_4n_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -111,9 +110,9 @@ uint8_t subghz_protocol_decoder_alutech_at_4n_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_alutech_at_4n_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_alutech_at_4n_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -122,11 +121,10 @@ bool subghz_protocol_decoder_alutech_at_4n_serialize(
  * Deserialize data SubGhzProtocolDecoderAlutech_at_4n.
  * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_alutech_at_4n_deserialize(
-    void* context,
-    FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_alutech_at_4n_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/ansonic.c b/lib/subghz/protocols/ansonic.c
index 81b196e369..9a122629be 100644
--- a/lib/subghz/protocols/ansonic.c
+++ b/lib/subghz/protocols/ansonic.c
@@ -136,28 +136,29 @@ static bool subghz_protocol_encoder_ansonic_get_upload(SubGhzProtocolEncoderAnso
     return true;
 }
 
-bool subghz_protocol_encoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderAnsonic* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        res = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_ansonic_const.min_count_bit_for_found);
+        if(res != SubGhzProtocolStatusOk) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_ansonic_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_ansonic_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_ansonic_get_upload(instance)) {
+            res = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
     return res;
@@ -301,7 +302,7 @@ uint8_t subghz_protocol_decoder_ansonic_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_ansonic_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_ansonic_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -310,22 +311,12 @@ bool subghz_protocol_decoder_ansonic_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderAnsonic* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_ansonic_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_ansonic_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_ansonic_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/ansonic.h b/lib/subghz/protocols/ansonic.h
index 0170a60489..9558531877 100644
--- a/lib/subghz/protocols/ansonic.h
+++ b/lib/subghz/protocols/ansonic.h
@@ -30,7 +30,8 @@ void subghz_protocol_encoder_ansonic_free(void* context);
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -86,7 +87,7 @@ uint8_t subghz_protocol_decoder_ansonic_get_hash_data(void* context);
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
  * @return true On success
  */
-bool subghz_protocol_decoder_ansonic_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_ansonic_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -97,7 +98,8 @@ bool subghz_protocol_decoder_ansonic_serialize(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_decoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/base.c b/lib/subghz/protocols/base.c
index 36f33b9a5c..37d1a308f0 100644
--- a/lib/subghz/protocols/base.c
+++ b/lib/subghz/protocols/base.c
@@ -23,11 +23,11 @@ bool subghz_protocol_decoder_base_get_string(
     return status;
 }
 
-bool subghz_protocol_decoder_base_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_base_serialize(
     SubGhzProtocolDecoderBase* decoder_base,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
-    bool status = false;
+    SubGhzProtocolStatus status = SubGhzProtocolStatusError;
 
     if(decoder_base->protocol && decoder_base->protocol->decoder &&
        decoder_base->protocol->decoder->serialize) {
@@ -37,10 +37,10 @@ bool subghz_protocol_decoder_base_serialize(
     return status;
 }
 
-bool subghz_protocol_decoder_base_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_base_deserialize(
     SubGhzProtocolDecoderBase* decoder_base,
     FlipperFormat* flipper_format) {
-    bool status = false;
+    SubGhzProtocolStatus status = SubGhzProtocolStatusError;
 
     if(decoder_base->protocol && decoder_base->protocol->decoder &&
        decoder_base->protocol->decoder->deserialize) {
diff --git a/lib/subghz/protocols/base.h b/lib/subghz/protocols/base.h
index 1f3d3e1bec..1d819ab5ef 100644
--- a/lib/subghz/protocols/base.h
+++ b/lib/subghz/protocols/base.h
@@ -49,9 +49,9 @@ bool subghz_protocol_decoder_base_get_string(
  * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return Status Error
  */
-bool subghz_protocol_decoder_base_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_base_serialize(
     SubGhzProtocolDecoderBase* decoder_base,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -60,9 +60,9 @@ bool subghz_protocol_decoder_base_serialize(
  * Deserialize data SubGhzProtocolDecoderBase.
  * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return Status Error
  */
-bool subghz_protocol_decoder_base_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_base_deserialize(
     SubGhzProtocolDecoderBase* decoder_base,
     FlipperFormat* flipper_format);
 
diff --git a/lib/subghz/protocols/bett.c b/lib/subghz/protocols/bett.c
index 644d80fd83..de13472ac7 100644
--- a/lib/subghz/protocols/bett.c
+++ b/lib/subghz/protocols/bett.c
@@ -155,31 +155,32 @@ static bool subghz_protocol_encoder_bett_get_upload(SubGhzProtocolEncoderBETT* i
     return true;
 }
 
-bool subghz_protocol_encoder_bett_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bett_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderBETT* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_bett_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_bett_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_bett_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_bett_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_bett_stop(void* context) {
@@ -295,7 +296,7 @@ uint8_t subghz_protocol_decoder_bett_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_bett_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_bett_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -304,22 +305,12 @@ bool subghz_protocol_decoder_bett_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_bett_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bett_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderBETT* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_bett_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_bett_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_bett_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/bett.h b/lib/subghz/protocols/bett.h
index c0ce0b7f42..0a11cbe697 100644
--- a/lib/subghz/protocols/bett.h
+++ b/lib/subghz/protocols/bett.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_bett_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderBETT instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_bett_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bett_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_bett_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderBETT instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_bett_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_bett_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_bett_serialize(
  * Deserialize data SubGhzProtocolDecoderBETT.
  * @param context Pointer to a SubGhzProtocolDecoderBETT instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_bett_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bett_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/bin_raw.c b/lib/subghz/protocols/bin_raw.c
index 67e0467ee5..003cc5eddf 100644
--- a/lib/subghz/protocols/bin_raw.c
+++ b/lib/subghz/protocols/bin_raw.c
@@ -219,20 +219,23 @@ static bool subghz_protocol_encoder_bin_raw_get_upload(SubGhzProtocolEncoderBinR
     return true;
 }
 
-bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderBinRAW* instance = context;
 
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     uint32_t temp_data = 0;
 
     do {
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
 
@@ -240,6 +243,7 @@ bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* f
 
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
+            res = SubGhzProtocolStatusErrorParserTe;
             break;
         }
 
@@ -251,11 +255,13 @@ bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* f
         while(flipper_format_read_uint32(flipper_format, "Bit_RAW", (uint32_t*)&temp_data, 1)) {
             if(ind >= BIN_RAW_MAX_MARKUP_COUNT) {
                 FURI_LOG_E(TAG, "Markup overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             byte_count += subghz_protocol_bin_raw_get_full_byte(temp_data);
             if(byte_count > BIN_RAW_BUF_DATA_SIZE) {
                 FURI_LOG_E(TAG, "Receive buffer overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
 
@@ -270,6 +276,7 @@ bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* f
                    subghz_protocol_bin_raw_get_full_byte(temp_data))) {
                 instance->data_markup[ind].bit_count = 0;
                 FURI_LOG_E(TAG, "Missing Data_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             ind++;
@@ -297,16 +304,20 @@ bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* f
 #endif
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_bin_raw_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_bin_raw_get_upload(instance)) {
+            break;
+            res = SubGhzProtocolStatusErrorEncoderGetUpload;
+        }
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(0);
 
     return res;
@@ -957,14 +968,14 @@ uint8_t subghz_protocol_decoder_bin_raw_get_hash_data(void* context) {
         subghz_protocol_bin_raw_get_full_byte(instance->data_markup[0].bit_count));
 }
 
-bool subghz_protocol_decoder_bin_raw_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_bin_raw_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderBinRAW* instance = context;
 
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     do {
@@ -972,11 +983,13 @@ bool subghz_protocol_decoder_bin_raw_serialize(
         if(!flipper_format_write_header_cstr(
                flipper_format, SUBGHZ_KEY_FILE_TYPE, SUBGHZ_KEY_FILE_VERSION)) {
             FURI_LOG_E(TAG, "Unable to add header");
+            res = SubGhzProtocolStatusErrorParserHeader;
             break;
         }
 
         if(!flipper_format_write_uint32(flipper_format, "Frequency", &preset->frequency, 1)) {
             FURI_LOG_E(TAG, "Unable to add Frequency");
+            res = SubGhzProtocolStatusErrorParserFrequency;
             break;
         }
 
@@ -984,34 +997,40 @@ bool subghz_protocol_decoder_bin_raw_serialize(
         if(!flipper_format_write_string_cstr(
                flipper_format, "Preset", furi_string_get_cstr(temp_str))) {
             FURI_LOG_E(TAG, "Unable to add Preset");
+            res = SubGhzProtocolStatusErrorParserPreset;
             break;
         }
         if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
             if(!flipper_format_write_string_cstr(
                    flipper_format, "Custom_preset_module", "CC1101")) {
                 FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
                 break;
             }
             if(!flipper_format_write_hex(
                    flipper_format, "Custom_preset_data", preset->data, preset->data_size)) {
                 FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
                 break;
             }
         }
         if(!flipper_format_write_string_cstr(
                flipper_format, "Protocol", instance->generic.protocol_name)) {
             FURI_LOG_E(TAG, "Unable to add Protocol");
+            res = SubGhzProtocolStatusErrorParserProtocolName;
             break;
         }
 
         uint32_t temp = instance->generic.data_count_bit;
         if(!flipper_format_write_uint32(flipper_format, "Bit", &temp, 1)) {
             FURI_LOG_E(TAG, "Unable to add Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
 
         if(!flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
             FURI_LOG_E(TAG, "Unable to add TE");
+            res = SubGhzProtocolStatusErrorParserTe;
             break;
         }
 
@@ -1020,6 +1039,7 @@ bool subghz_protocol_decoder_bin_raw_serialize(
             temp = instance->data_markup[i].bit_count;
             if(!flipper_format_write_uint32(flipper_format, "Bit_RAW", &temp, 1)) {
                 FURI_LOG_E(TAG, "Bit_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             if(!flipper_format_write_hex(
@@ -1028,31 +1048,35 @@ bool subghz_protocol_decoder_bin_raw_serialize(
                    instance->data + instance->data_markup[i].byte_bias,
                    subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count))) {
                 FURI_LOG_E(TAG, "Unable to add Data_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             i++;
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
     furi_string_free(temp_str);
     return res;
 }
 
-bool subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderBinRAW* instance = context;
 
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     uint32_t temp_data = 0;
 
     do {
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
             FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
             break;
         }
 
@@ -1060,6 +1084,7 @@ bool subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* f
 
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
+            res = SubGhzProtocolStatusErrorParserTe;
             break;
         }
 
@@ -1071,11 +1096,13 @@ bool subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* f
         while(flipper_format_read_uint32(flipper_format, "Bit_RAW", (uint32_t*)&temp_data, 1)) {
             if(ind >= BIN_RAW_MAX_MARKUP_COUNT) {
                 FURI_LOG_E(TAG, "Markup overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             byte_count += subghz_protocol_bin_raw_get_full_byte(temp_data);
             if(byte_count > BIN_RAW_BUF_DATA_SIZE) {
                 FURI_LOG_E(TAG, "Receive buffer overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
 
@@ -1090,12 +1117,13 @@ bool subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* f
                    subghz_protocol_bin_raw_get_full_byte(temp_data))) {
                 instance->data_markup[ind].bit_count = 0;
                 FURI_LOG_E(TAG, "Missing Data_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             ind++;
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(0);
 
     return res;
diff --git a/lib/subghz/protocols/bin_raw.h b/lib/subghz/protocols/bin_raw.h
index c63f86ce6f..82775e5759 100644
--- a/lib/subghz/protocols/bin_raw.h
+++ b/lib/subghz/protocols/bin_raw.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_bin_raw_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -88,9 +89,9 @@ void subghz_protocol_decoder_bin_raw_data_input_rssi(
  * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_bin_raw_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_bin_raw_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -99,9 +100,10 @@ bool subghz_protocol_decoder_bin_raw_serialize(
  * Deserialize data SubGhzProtocolDecoderBinRAW.
  * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/came.c b/lib/subghz/protocols/came.c
index 00e2f49f2c..14b2e0101c 100644
--- a/lib/subghz/protocols/came.c
+++ b/lib/subghz/protocols/came.c
@@ -13,6 +13,7 @@
  */
 
 #define TAG "SubGhzProtocolCAME"
+#define CAME_12_COUNT_BIT 12
 #define CAME_24_COUNT_BIT 24
 #define PRASTEL_COUNT_BIT 25
 #define PRASTEL_NAME "Prastel"
@@ -108,6 +109,7 @@ void subghz_protocol_encoder_came_free(void* context) {
  */
 static bool subghz_protocol_encoder_came_get_upload(SubGhzProtocolEncoderCame* instance) {
     furi_assert(instance);
+    uint32_t header_te = 0;
     size_t index = 0;
     size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
     if(size_upload > instance->encoder.size_upload) {
@@ -117,25 +119,28 @@ static bool subghz_protocol_encoder_came_get_upload(SubGhzProtocolEncoderCame* i
         instance->encoder.size_upload = size_upload;
     }
     //Send header
-    // CAME 24 Bit = 24320 us
-    if(instance->generic.data_count_bit == CAME_24_COUNT_BIT) {
-        instance->encoder.upload[index++] =
-            level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short * 76);
-    } else if(
-        (instance->generic.data_count_bit == subghz_protocol_came_const.min_count_bit_for_found) ||
-        (instance->generic.data_count_bit == AIRFORCE_COUNT_BIT)) {
+
+    switch(instance->generic.data_count_bit) {
+    case CAME_24_COUNT_BIT:
+        // CAME 24 Bit = 24320 us
+        header_te = 76;
+        break;
+    case CAME_12_COUNT_BIT:
+    case AIRFORCE_COUNT_BIT:
         // CAME 12 Bit Original only! and Airforce protocol = 15040 us
-        instance->encoder.upload[index++] =
-            level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short * 47);
-    } else if(instance->generic.data_count_bit == PRASTEL_COUNT_BIT) {
+        header_te = 47;
+        break;
+    case PRASTEL_COUNT_BIT:
         // PRASTEL = 11520 us
-        instance->encoder.upload[index++] =
-            level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short * 36);
-    } else {
+        header_te = 36;
+        break;
+    default:
         // Some wrong detected protocols, 5120 us
-        instance->encoder.upload[index++] =
-            level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short * 16);
+        header_te = 16;
+        break;
     }
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short * header_te);
     //Send start bit
     instance->encoder.upload[index++] =
         level_duration_make(true, (uint32_t)subghz_protocol_came_const.te_short);
@@ -158,30 +163,33 @@ static bool subghz_protocol_encoder_came_get_upload(SubGhzProtocolEncoderCame* i
     return true;
 }
 
-bool subghz_protocol_encoder_came_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderCame* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit > PRASTEL_COUNT_BIT)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_came_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_came_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_came_stop(void* context) {
@@ -256,8 +264,11 @@ void subghz_protocol_decoder_came_feed(void* context, bool level, uint32_t durat
         if(!level) { //save interval
             if(duration >= (subghz_protocol_came_const.te_short * 4)) {
                 instance->decoder.parser_step = CameDecoderStepFoundStartBit;
-                if(instance->decoder.decode_count_bit >=
-                   subghz_protocol_came_const.min_count_bit_for_found) {
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_came_const.min_count_bit_for_found) ||
+                   (instance->decoder.decode_count_bit == AIRFORCE_COUNT_BIT) ||
+                   (instance->decoder.decode_count_bit == PRASTEL_COUNT_BIT) ||
+                   (instance->decoder.decode_count_bit == CAME_24_COUNT_BIT)) {
                     instance->generic.serial = 0x0;
                     instance->generic.btn = 0x0;
 
@@ -306,7 +317,7 @@ uint8_t subghz_protocol_decoder_came_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_came_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_came_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -315,19 +326,21 @@ bool subghz_protocol_decoder_came_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_came_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderCame* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit > PRASTEL_COUNT_BIT)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/came.h b/lib/subghz/protocols/came.h
index 253c93aaea..fffa017ff5 100644
--- a/lib/subghz/protocols/came.h
+++ b/lib/subghz/protocols/came.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_came_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderCame instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_came_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_came_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderCame instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_came_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_came_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_came_serialize(
  * Deserialize data SubGhzProtocolDecoderCame.
  * @param context Pointer to a SubGhzProtocolDecoderCame instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_came_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/came_atomo.c b/lib/subghz/protocols/came_atomo.c
index 45403d2798..870afede3d 100644
--- a/lib/subghz/protocols/came_atomo.c
+++ b/lib/subghz/protocols/came_atomo.c
@@ -223,12 +223,14 @@ static void
     instance->generic.data &= 0xFFFFFFFFFFFFFFF;
 }
 
-bool subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderCameAtomo* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -255,7 +257,7 @@ bool subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -549,7 +551,7 @@ uint8_t subghz_protocol_decoder_came_atomo_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_came_atomo_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_came_atomo_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -558,22 +560,14 @@ bool subghz_protocol_decoder_came_atomo_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderCameAtomo* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_came_atomo_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_came_atomo_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_came_atomo_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/came_atomo.h b/lib/subghz/protocols/came_atomo.h
index 736aee8506..c5e45a68d8 100644
--- a/lib/subghz/protocols/came_atomo.h
+++ b/lib/subghz/protocols/came_atomo.h
@@ -33,7 +33,8 @@ void subghz_protocol_encoder_came_atomo_free(void* context);
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -87,9 +88,9 @@ uint8_t subghz_protocol_decoder_came_atomo_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_came_atomo_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_came_atomo_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -98,9 +99,10 @@ bool subghz_protocol_decoder_came_atomo_serialize(
  * Deserialize data SubGhzProtocolDecoderCameAtomo.
  * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/came_twee.c b/lib/subghz/protocols/came_twee.c
index e7eb33c428..6fe6158139 100644
--- a/lib/subghz/protocols/came_twee.c
+++ b/lib/subghz/protocols/came_twee.c
@@ -241,18 +241,17 @@ static void subghz_protocol_came_twee_remote_controller(SubGhzBlockGeneric* inst
     instance->cnt = data >> 6;
 }
 
-bool subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderCameTwee* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_came_twee_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        res = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_came_twee_const.min_count_bit_for_found);
+        if(res != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
@@ -262,8 +261,6 @@ bool subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat*
         subghz_protocol_came_twee_remote_controller(&instance->generic);
         subghz_protocol_encoder_came_twee_get_upload(instance);
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
     return res;
@@ -419,7 +416,7 @@ uint8_t subghz_protocol_decoder_came_twee_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_came_twee_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_came_twee_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -428,22 +425,14 @@ bool subghz_protocol_decoder_came_twee_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderCameTwee* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_came_twee_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_came_twee_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_came_twee_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/came_twee.h b/lib/subghz/protocols/came_twee.h
index 359b964da7..f26f1e8062 100644
--- a/lib/subghz/protocols/came_twee.h
+++ b/lib/subghz/protocols/came_twee.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_came_twee_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderCameTwee instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_came_twee_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_came_twee_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_came_twee_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_came_twee_serialize(
  * Deserialize data SubGhzProtocolDecoderCameTwee.
  * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/chamberlain_code.c b/lib/subghz/protocols/chamberlain_code.c
index 9c8e5ee4ad..be0877fb5c 100644
--- a/lib/subghz/protocols/chamberlain_code.c
+++ b/lib/subghz/protocols/chamberlain_code.c
@@ -207,31 +207,35 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderChamb_Code* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(instance->generic.data_count_bit >
            subghz_protocol_chamb_code_const.min_count_bit_for_found) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_chamb_code_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_chamb_code_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
 
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_chamb_code_stop(void* context) {
@@ -425,7 +429,7 @@ uint8_t subghz_protocol_decoder_chamb_code_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_chamb_code_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_chamb_code_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -434,20 +438,22 @@ bool subghz_protocol_decoder_chamb_code_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderChamb_Code* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(instance->generic.data_count_bit >
            subghz_protocol_chamb_code_const.min_count_bit_for_found) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/chamberlain_code.h b/lib/subghz/protocols/chamberlain_code.h
index f87b64d901..c8ffed5c50 100644
--- a/lib/subghz/protocols/chamberlain_code.h
+++ b/lib/subghz/protocols/chamberlain_code.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_chamb_code_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderChamb_Code instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_chamb_code_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_chamb_code_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_chamb_code_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_chamb_code_serialize(
  * Deserialize data SubGhzProtocolDecoderChamb_Code.
  * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/clemsa.c b/lib/subghz/protocols/clemsa.c
index a2cb7a18bd..a0547a1137 100644
--- a/lib/subghz/protocols/clemsa.c
+++ b/lib/subghz/protocols/clemsa.c
@@ -155,31 +155,32 @@ static bool subghz_protocol_encoder_clemsa_get_upload(SubGhzProtocolEncoderClems
     return true;
 }
 
-bool subghz_protocol_encoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderClemsa* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_clemsa_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_clemsa_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_clemsa_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_clemsa_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
 
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_clemsa_stop(void* context) {
@@ -316,7 +317,7 @@ uint8_t subghz_protocol_decoder_clemsa_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_clemsa_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_clemsa_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -325,22 +326,12 @@ bool subghz_protocol_decoder_clemsa_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderClemsa* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_clemsa_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_clemsa_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_clemsa_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/clemsa.h b/lib/subghz/protocols/clemsa.h
index 8858c1a3ba..f14cd3dace 100644
--- a/lib/subghz/protocols/clemsa.h
+++ b/lib/subghz/protocols/clemsa.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_clemsa_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderClemsa instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_clemsa_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_clemsa_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_clemsa_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_clemsa_serialize(
  * Deserialize data SubGhzProtocolDecoderClemsa.
  * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/doitrand.c b/lib/subghz/protocols/doitrand.c
index 6b31d4f271..69b8bba4ae 100644
--- a/lib/subghz/protocols/doitrand.c
+++ b/lib/subghz/protocols/doitrand.c
@@ -136,31 +136,31 @@ static bool subghz_protocol_encoder_doitrand_get_upload(SubGhzProtocolEncoderDoi
     return true;
 }
 
-bool subghz_protocol_encoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderDoitrand* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_doitrand_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_doitrand_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_doitrand_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_doitrand_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_doitrand_stop(void* context) {
@@ -310,7 +310,7 @@ uint8_t subghz_protocol_decoder_doitrand_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_doitrand_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_doitrand_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -319,22 +319,14 @@ bool subghz_protocol_decoder_doitrand_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderDoitrand* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_doitrand_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_doitrand_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_doitrand_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/doitrand.h b/lib/subghz/protocols/doitrand.h
index 30f1fffd0d..5dbc6678fd 100644
--- a/lib/subghz/protocols/doitrand.h
+++ b/lib/subghz/protocols/doitrand.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_doitrand_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderDoitrand instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_doitrand_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_doitrand_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_doitrand_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_doitrand_serialize(
  * Deserialize data SubGhzProtocolDecoderDoitrand.
  * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/dooya.c b/lib/subghz/protocols/dooya.c
index c70b6d54ee..47e95209e5 100644
--- a/lib/subghz/protocols/dooya.c
+++ b/lib/subghz/protocols/dooya.c
@@ -146,31 +146,31 @@ static bool subghz_protocol_encoder_dooya_get_upload(SubGhzProtocolEncoderDooya*
     return true;
 }
 
-bool subghz_protocol_encoder_dooya_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_dooya_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderDooya* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_dooya_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_dooya_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_dooya_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_dooya_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_dooya_stop(void* context) {
@@ -354,7 +354,7 @@ uint8_t subghz_protocol_decoder_dooya_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_dooya_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_dooya_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -363,22 +363,12 @@ bool subghz_protocol_decoder_dooya_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_dooya_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_dooya_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderDooya* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_dooya_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_dooya_const.min_count_bit_for_found);
 }
 
 /**
diff --git a/lib/subghz/protocols/dooya.h b/lib/subghz/protocols/dooya.h
index f0cf843c0d..ffe9d41eff 100644
--- a/lib/subghz/protocols/dooya.h
+++ b/lib/subghz/protocols/dooya.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_dooya_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderDooya instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_dooya_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_dooya_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_dooya_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderDooya instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_dooya_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_dooya_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_dooya_serialize(
  * Deserialize data SubGhzProtocolDecoderDooya.
  * @param context Pointer to a SubGhzProtocolDecoderDooya instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_dooya_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_dooya_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/faac_slh.c b/lib/subghz/protocols/faac_slh.c
index 4b69ae73d1..c1c96b7a73 100644
--- a/lib/subghz/protocols/faac_slh.c
+++ b/lib/subghz/protocols/faac_slh.c
@@ -169,7 +169,8 @@ bool subghz_protocol_faac_slh_create_data(
     instance->generic.data_count_bit = 64;
     bool res = subghz_protocol_faac_slh_gen_data(instance);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -217,12 +218,14 @@ static bool subghz_protocol_encoder_faac_slh_get_upload(SubGhzProtocolEncoderFaa
     return true;
 }
 
-bool subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderFaacSLH* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -261,7 +264,7 @@ bool subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat*
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -422,22 +425,24 @@ uint8_t subghz_protocol_decoder_faac_slh_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_faac_slh_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_faac_slh_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderFaacSLH* instance = context;
 
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
     uint8_t seed_data[sizeof(uint32_t)] = {0};
     for(size_t i = 0; i < sizeof(uint32_t); i++) {
         seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
     }
-    if(res && !flipper_format_write_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
         FURI_LOG_E(TAG, "Unable to add Seed");
-        res = false;
+        res = SubGhzProtocolStatusError;
     }
     instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
                              seed_data[3];
@@ -448,12 +453,14 @@ bool subghz_protocol_decoder_faac_slh_serialize(
     return res;
 }
 
-bool subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderFaacSLH* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -478,7 +485,7 @@ bool subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat*
             FURI_LOG_E(TAG, "Rewind error");
             break;
         }
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
diff --git a/lib/subghz/protocols/faac_slh.h b/lib/subghz/protocols/faac_slh.h
index 9390da43a1..bab042ca6e 100644
--- a/lib/subghz/protocols/faac_slh.h
+++ b/lib/subghz/protocols/faac_slh.h
@@ -52,7 +52,8 @@ bool subghz_protocol_faac_slh_create_data(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -106,9 +107,9 @@ uint8_t subghz_protocol_decoder_faac_slh_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_faac_slh_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_faac_slh_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -117,9 +118,10 @@ bool subghz_protocol_decoder_faac_slh_serialize(
  * Deserialize data SubGhzProtocolDecoderFaacSLH.
  * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/gate_tx.c b/lib/subghz/protocols/gate_tx.c
index 4c7c2d4845..51a424fed9 100644
--- a/lib/subghz/protocols/gate_tx.c
+++ b/lib/subghz/protocols/gate_tx.c
@@ -129,31 +129,31 @@ static bool subghz_protocol_encoder_gate_tx_get_upload(SubGhzProtocolEncoderGate
     return true;
 }
 
-bool subghz_protocol_encoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderGateTx* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_gate_tx_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_gate_tx_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_gate_tx_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_gate_tx_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_gate_tx_stop(void* context) {
@@ -290,7 +290,7 @@ uint8_t subghz_protocol_decoder_gate_tx_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_gate_tx_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_gate_tx_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -299,22 +299,12 @@ bool subghz_protocol_decoder_gate_tx_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderGateTx* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_gate_tx_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_gate_tx_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_gate_tx_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/gate_tx.h b/lib/subghz/protocols/gate_tx.h
index 4bfba3597c..a6abede0d7 100644
--- a/lib/subghz/protocols/gate_tx.h
+++ b/lib/subghz/protocols/gate_tx.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_gate_tx_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderGateTx instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_gate_tx_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_gate_tx_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_gate_tx_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_gate_tx_serialize(
  * Deserialize data SubGhzProtocolDecoderGateTx.
  * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/holtek.c b/lib/subghz/protocols/holtek.c
index 8aaad3b717..294bd124d3 100644
--- a/lib/subghz/protocols/holtek.c
+++ b/lib/subghz/protocols/holtek.c
@@ -142,31 +142,31 @@ static bool subghz_protocol_encoder_holtek_get_upload(SubGhzProtocolEncoderHolte
     return true;
 }
 
-bool subghz_protocol_encoder_holtek_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderHoltek* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_holtek_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_holtek_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_holtek_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_holtek_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_holtek_stop(void* context) {
@@ -322,7 +322,7 @@ uint8_t subghz_protocol_decoder_holtek_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_holtek_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -331,22 +331,12 @@ bool subghz_protocol_decoder_holtek_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_holtek_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderHoltek* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_holtek_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_holtek_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_holtek_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/holtek.h b/lib/subghz/protocols/holtek.h
index 252a26dc7c..19081308d3 100644
--- a/lib/subghz/protocols/holtek.h
+++ b/lib/subghz/protocols/holtek.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_holtek_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderHoltek instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_holtek_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_holtek_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_holtek_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_holtek_serialize(
  * Deserialize data SubGhzProtocolDecoderHoltek.
  * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_holtek_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/holtek_ht12x.c b/lib/subghz/protocols/holtek_ht12x.c
index 169387dedd..831f824dd6 100644
--- a/lib/subghz/protocols/holtek_ht12x.c
+++ b/lib/subghz/protocols/holtek_ht12x.c
@@ -147,39 +147,41 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderHoltek_HT12X* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_holtek_th12x_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_holtek_th12x_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorParserTe;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_holtek_th12x_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_holtek_th12x_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_holtek_th12x_stop(void* context) {
@@ -327,42 +329,45 @@ uint8_t subghz_protocol_decoder_holtek_th12x_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_holtek_th12x_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_th12x_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderHoltek_HT12X* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
-    if(res && !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
         FURI_LOG_E(TAG, "Unable to add TE");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserTe;
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderHoltek_HT12X* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_holtek_th12x_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_holtek_th12x_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/holtek_ht12x.h b/lib/subghz/protocols/holtek_ht12x.h
index 7b5c31dd73..500c061aa3 100644
--- a/lib/subghz/protocols/holtek_ht12x.h
+++ b/lib/subghz/protocols/holtek_ht12x.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_holtek_th12x_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_holtek_th12x_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_holtek_th12x_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_th12x_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_holtek_th12x_serialize(
  * Deserialize data SubGhzProtocolDecoderHoltek_HT12X.
  * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/honeywell_wdb.c b/lib/subghz/protocols/honeywell_wdb.c
index 3b940fc677..7fd8d66d6f 100644
--- a/lib/subghz/protocols/honeywell_wdb.c
+++ b/lib/subghz/protocols/honeywell_wdb.c
@@ -142,33 +142,32 @@ static bool subghz_protocol_encoder_honeywell_wdb_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_honeywell_wdb_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_honeywell_wdb_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderHoneywell_WDB* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_honeywell_wdb_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_honeywell_wdb_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_honeywell_wdb_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_honeywell_wdb_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_honeywell_wdb_stop(void* context) {
@@ -345,7 +344,7 @@ uint8_t subghz_protocol_decoder_honeywell_wdb_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_honeywell_wdb_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_wdb_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -354,24 +353,15 @@ bool subghz_protocol_decoder_honeywell_wdb_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_honeywell_wdb_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_wdb_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderHoneywell_WDB* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_honeywell_wdb_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_honeywell_wdb_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_honeywell_wdb_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/honeywell_wdb.h b/lib/subghz/protocols/honeywell_wdb.h
index 828631837d..91728691b0 100644
--- a/lib/subghz/protocols/honeywell_wdb.h
+++ b/lib/subghz/protocols/honeywell_wdb.h
@@ -28,11 +28,10 @@ void subghz_protocol_encoder_honeywell_wdb_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_honeywell_wdb_deserialize(
-    void* context,
-    FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honeywell_wdb_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -86,9 +85,9 @@ uint8_t subghz_protocol_decoder_honeywell_wdb_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_honeywell_wdb_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_wdb_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -97,11 +96,10 @@ bool subghz_protocol_decoder_honeywell_wdb_serialize(
  * Deserialize data SubGhzProtocolDecoderHoneywell_WDB.
  * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_honeywell_wdb_deserialize(
-    void* context,
-    FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honeywell_wdb_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/hormann.c b/lib/subghz/protocols/hormann.c
index 67b8cdfca4..4c5c68cc44 100644
--- a/lib/subghz/protocols/hormann.c
+++ b/lib/subghz/protocols/hormann.c
@@ -140,31 +140,31 @@ static bool subghz_protocol_encoder_hormann_get_upload(SubGhzProtocolEncoderHorm
     return true;
 }
 
-bool subghz_protocol_encoder_hormann_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hormann_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderHormann* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_hormann_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_hormann_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_hormann_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_hormann_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_hormann_stop(void* context) {
@@ -295,7 +295,7 @@ uint8_t subghz_protocol_decoder_hormann_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_hormann_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_hormann_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -304,22 +304,12 @@ bool subghz_protocol_decoder_hormann_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_hormann_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hormann_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderHormann* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_hormann_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_hormann_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_hormann_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/hormann.h b/lib/subghz/protocols/hormann.h
index 857a50041b..8cb45aec32 100644
--- a/lib/subghz/protocols/hormann.h
+++ b/lib/subghz/protocols/hormann.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_hormann_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderHormann instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_hormann_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hormann_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_hormann_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderHormann instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_hormann_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_hormann_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_hormann_serialize(
  * Deserialize data SubGhzProtocolDecoderHormann.
  * @param context Pointer to a SubGhzProtocolDecoderHormann instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_hormann_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hormann_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/ido.c b/lib/subghz/protocols/ido.c
index dff9defc0d..70870dd937 100644
--- a/lib/subghz/protocols/ido.c
+++ b/lib/subghz/protocols/ido.c
@@ -180,7 +180,7 @@ uint8_t subghz_protocol_decoder_ido_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_ido_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_ido_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -189,21 +189,12 @@ bool subghz_protocol_decoder_ido_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_ido_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ido_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderIDo* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit != subghz_protocol_ido_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_ido_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_ido_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/ido.h b/lib/subghz/protocols/ido.h
index 634f6ff89c..9493202466 100644
--- a/lib/subghz/protocols/ido.h
+++ b/lib/subghz/protocols/ido.h
@@ -50,9 +50,9 @@ uint8_t subghz_protocol_decoder_ido_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderIDo instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_ido_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_ido_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -61,9 +61,10 @@ bool subghz_protocol_decoder_ido_serialize(
  * Deserialize data SubGhzProtocolDecoderIDo.
  * @param context Pointer to a SubGhzProtocolDecoderIDo instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_ido_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ido_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/intertechno_v3.c b/lib/subghz/protocols/intertechno_v3.c
index 2c4e514cce..7fe9529955 100644
--- a/lib/subghz/protocols/intertechno_v3.c
+++ b/lib/subghz/protocols/intertechno_v3.c
@@ -158,34 +158,36 @@ static bool subghz_protocol_encoder_intertechno_v3_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_intertechno_v3_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_intertechno_v3_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderIntertechno_V3* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit !=
             subghz_protocol_intertechno_v3_const.min_count_bit_for_found) &&
            (instance->generic.data_count_bit != INTERTECHNO_V3_DIMMING_COUNT_BIT)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_intertechno_v3_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_intertechno_v3_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_intertechno_v3_stop(void* context) {
@@ -404,7 +406,7 @@ uint8_t subghz_protocol_decoder_intertechno_v3_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_intertechno_v3_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -413,23 +415,24 @@ bool subghz_protocol_decoder_intertechno_v3_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_intertechno_v3_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderIntertechno_V3* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit !=
             subghz_protocol_intertechno_v3_const.min_count_bit_for_found) &&
            (instance->generic.data_count_bit != INTERTECHNO_V3_DIMMING_COUNT_BIT)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/intertechno_v3.h b/lib/subghz/protocols/intertechno_v3.h
index ffee14b04f..4d1c24cb6b 100644
--- a/lib/subghz/protocols/intertechno_v3.h
+++ b/lib/subghz/protocols/intertechno_v3.h
@@ -28,9 +28,9 @@ void subghz_protocol_encoder_intertechno_v3_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return Starus error
  */
-bool subghz_protocol_encoder_intertechno_v3_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_intertechno_v3_deserialize(
     void* context,
     FlipperFormat* flipper_format);
 
@@ -86,9 +86,9 @@ uint8_t subghz_protocol_decoder_intertechno_v3_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return Starus error
  */
-bool subghz_protocol_decoder_intertechno_v3_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -97,9 +97,9 @@ bool subghz_protocol_decoder_intertechno_v3_serialize(
  * Deserialize data SubGhzProtocolDecoderIntertechno_V3.
  * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return Starus error
  */
-bool subghz_protocol_decoder_intertechno_v3_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_deserialize(
     void* context,
     FlipperFormat* flipper_format);
 
diff --git a/lib/subghz/protocols/keeloq.c b/lib/subghz/protocols/keeloq.c
index a58a95ed64..4bd978c8ff 100644
--- a/lib/subghz/protocols/keeloq.c
+++ b/lib/subghz/protocols/keeloq.c
@@ -312,7 +312,8 @@ bool subghz_protocol_keeloq_create_data(
     instance->generic.data_count_bit = 64;
     bool res = subghz_protocol_keeloq_gen_data(instance, btn, false);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -337,7 +338,8 @@ bool subghz_protocol_keeloq_bft_create_data(
     // roguuemaster don't steal.!!!!
     bool res = subghz_protocol_keeloq_gen_data(instance, btn, false);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -390,6 +392,7 @@ static bool
             break;
 
         default:
+            btn = 0x1;
             break;
         }
     }
@@ -415,6 +418,7 @@ static bool
             break;
 
         default:
+            btn = 0x4;
             break;
         }
     }
@@ -440,6 +444,7 @@ static bool
             break;
 
         default:
+            btn = 0x8;
             break;
         }
     }
@@ -465,6 +470,7 @@ static bool
             break;
 
         default:
+            btn = 0x2;
             break;
         }
     }
@@ -532,13 +538,17 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderKeeloq* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_keeloq_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(instance->generic.data_count_bit !=
@@ -578,10 +588,13 @@ bool subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* fl
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_keeloq_get_upload(instance, instance->generic.btn)) break;
-
+        if(!subghz_protocol_encoder_keeloq_get_upload(instance, instance->generic.btn)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         uint8_t key_data[sizeof(uint64_t)] = {0};
@@ -590,15 +603,14 @@ bool subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* fl
         }
         if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to add Key");
+            ret = SubGhzProtocolStatusErrorParserKey;
             break;
         }
 
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_keeloq_stop(void* context) {
@@ -1172,14 +1184,15 @@ uint8_t subghz_protocol_decoder_keeloq_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_keeloq_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_keeloq_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderKeeloq* instance = context;
 
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
     subghz_protocol_keeloq_check_remote_controller(
         &instance->generic, instance->keystore, &instance->manufacture_name);
@@ -1189,28 +1202,32 @@ bool subghz_protocol_decoder_keeloq_serialize(
         for(size_t i = 0; i < sizeof(uint32_t); i++) {
             seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
         }
-        if(res && !flipper_format_write_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+        if((res == SubGhzProtocolStatusOk) &&
+           !flipper_format_write_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
             FURI_LOG_E(TAG, "DECODER Serialize: Unable to add Seed");
-            res = false;
+            res = SubGhzProtocolStatusError;
         }
         instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
                                  seed_data[3];
     }
 
-    if(res && !flipper_format_write_string_cstr(
-                  flipper_format, "Manufacture", instance->manufacture_name)) {
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_string_cstr(
+           flipper_format, "Manufacture", instance->manufacture_name)) {
         FURI_LOG_E(TAG, "DECODER Serialize: Unable to add manufacture name");
-        res = false;
+        res = SubGhzProtocolStatusError;
     }
     return res;
 }
 
-bool subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderKeeloq* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -1244,7 +1261,7 @@ bool subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* fl
             break;
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
diff --git a/lib/subghz/protocols/keeloq.h b/lib/subghz/protocols/keeloq.h
index 9ddf17d898..f0715648c7 100644
--- a/lib/subghz/protocols/keeloq.h
+++ b/lib/subghz/protocols/keeloq.h
@@ -81,9 +81,10 @@ bool subghz_protocol_keeloq_bft_create_data(
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -137,9 +138,9 @@ uint8_t subghz_protocol_decoder_keeloq_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return SubGhzProtocolStatus
  */
-bool subghz_protocol_decoder_keeloq_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_keeloq_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -148,9 +149,10 @@ bool subghz_protocol_decoder_keeloq_serialize(
  * Deserialize data SubGhzProtocolDecoderKeeloq.
  * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return SubGhzProtocolStatus
  */
-bool subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/kia.c b/lib/subghz/protocols/kia.c
index a5d9e37ef0..1d134f7bab 100644
--- a/lib/subghz/protocols/kia.c
+++ b/lib/subghz/protocols/kia.c
@@ -230,7 +230,7 @@ uint8_t subghz_protocol_decoder_kia_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_kia_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_kia_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -239,21 +239,12 @@ bool subghz_protocol_decoder_kia_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_kia_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_kia_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderKIA* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit != subghz_protocol_kia_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_kia_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_kia_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/kia.h b/lib/subghz/protocols/kia.h
index a9afcf1498..749ff8afd2 100644
--- a/lib/subghz/protocols/kia.h
+++ b/lib/subghz/protocols/kia.h
@@ -50,9 +50,9 @@ uint8_t subghz_protocol_decoder_kia_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderKIA instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_kia_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_kia_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -61,9 +61,10 @@ bool subghz_protocol_decoder_kia_serialize(
  * Deserialize data SubGhzProtocolDecoderKIA.
  * @param context Pointer to a SubGhzProtocolDecoderKIA instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_kia_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_kia_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/kinggates_stylo_4k.c b/lib/subghz/protocols/kinggates_stylo_4k.c
index 1823a072a7..a9127d2b15 100644
--- a/lib/subghz/protocols/kinggates_stylo_4k.c
+++ b/lib/subghz/protocols/kinggates_stylo_4k.c
@@ -263,14 +263,15 @@ static bool subghz_protocol_encoder_kinggates_stylo_4k_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -314,7 +315,7 @@ bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -509,57 +510,57 @@ uint8_t subghz_protocol_decoder_kinggates_stylo_4k_get_hash_data(void* context)
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_kinggates_stylo_4k_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
     uint8_t key_data[sizeof(uint64_t)] = {0};
     for(size_t i = 0; i < sizeof(uint64_t); i++) {
         key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
     }
 
-    if(res && !flipper_format_write_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
         FURI_LOG_E(TAG, "Unable to add Data");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserOthers;
     }
-    return res;
-
-    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    return ret;
 }
 
-bool subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_kinggates_stylo_4k_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_kinggates_stylo_4k_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Missing Data");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
             instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/kinggates_stylo_4k.h b/lib/subghz/protocols/kinggates_stylo_4k.h
index 9717f67153..cdefebc840 100644
--- a/lib/subghz/protocols/kinggates_stylo_4k.h
+++ b/lib/subghz/protocols/kinggates_stylo_4k.h
@@ -29,7 +29,7 @@ void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context);
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
     void* context,
     FlipperFormat* flipper_format);
 
@@ -85,9 +85,9 @@ uint8_t subghz_protocol_decoder_kinggates_stylo_4k_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_kinggates_stylo_4k_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -96,9 +96,9 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_serialize(
  * Deserialize data SubGhzProtocolDecoderKingGates_stylo_4k.
  * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
     void* context,
     FlipperFormat* flipper_format);
 
diff --git a/lib/subghz/protocols/linear.c b/lib/subghz/protocols/linear.c
index 2fc8b20c87..8d37357966 100644
--- a/lib/subghz/protocols/linear.c
+++ b/lib/subghz/protocols/linear.c
@@ -147,31 +147,31 @@ static bool subghz_protocol_encoder_linear_get_upload(SubGhzProtocolEncoderLinea
     return true;
 }
 
-bool subghz_protocol_encoder_linear_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_linear_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderLinear* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_linear_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_linear_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_linear_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_linear_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_linear_stop(void* context) {
@@ -300,7 +300,7 @@ uint8_t subghz_protocol_decoder_linear_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_linear_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_linear_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -309,22 +309,12 @@ bool subghz_protocol_decoder_linear_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_linear_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_linear_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderLinear* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_linear_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_linear_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_linear_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/linear.h b/lib/subghz/protocols/linear.h
index 923337ac21..b692b911c1 100644
--- a/lib/subghz/protocols/linear.h
+++ b/lib/subghz/protocols/linear.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_linear_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderLinear instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_linear_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_linear_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_linear_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderLinear instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_linear_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_linear_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_linear_serialize(
  * Deserialize data SubGhzProtocolDecoderLinear.
  * @param context Pointer to a SubGhzProtocolDecoderLinear instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_linear_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_linear_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/linear_delta3.c b/lib/subghz/protocols/linear_delta3.c
index 869edac84e..97ac5cc5a6 100644
--- a/lib/subghz/protocols/linear_delta3.c
+++ b/lib/subghz/protocols/linear_delta3.c
@@ -150,33 +150,32 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_linear_delta3_deserialize(
+SubGhzProtocolStatus subghz_protocol_encoder_linear_delta3_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderLinearDelta3* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_linear_delta3_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_linear_delta3_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_linear_delta3_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_linear_delta3_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_linear_delta3_stop(void* context) {
@@ -312,7 +311,7 @@ uint8_t subghz_protocol_decoder_linear_delta3_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8));
 }
 
-bool subghz_protocol_decoder_linear_delta3_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_linear_delta3_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -321,24 +320,15 @@ bool subghz_protocol_decoder_linear_delta3_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_linear_delta3_deserialize(
+SubGhzProtocolStatus subghz_protocol_decoder_linear_delta3_deserialize(
     void* context,
     FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderLinearDelta3* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_linear_delta3_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_linear_delta3_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_linear_delta3_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/linear_delta3.h b/lib/subghz/protocols/linear_delta3.h
index 2f0a32e682..22f6730f44 100644
--- a/lib/subghz/protocols/linear_delta3.h
+++ b/lib/subghz/protocols/linear_delta3.h
@@ -28,11 +28,10 @@ void subghz_protocol_encoder_linear_delta3_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderLinearDelta3 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_linear_delta3_deserialize(
-    void* context,
-    FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_linear_delta3_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -86,9 +85,9 @@ uint8_t subghz_protocol_decoder_linear_delta3_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_linear_delta3_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_linear_delta3_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -97,11 +96,10 @@ bool subghz_protocol_decoder_linear_delta3_serialize(
  * Deserialize data SubGhzProtocolDecoderLinearDelta3.
  * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_linear_delta3_deserialize(
-    void* context,
-    FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_linear_delta3_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/magellan.c b/lib/subghz/protocols/magellan.c
index 67d3fe3d36..2d02a866c2 100644
--- a/lib/subghz/protocols/magellan.c
+++ b/lib/subghz/protocols/magellan.c
@@ -150,31 +150,31 @@ static bool subghz_protocol_encoder_magellan_get_upload(SubGhzProtocolEncoderMag
     return true;
 }
 
-bool subghz_protocol_encoder_magellan_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_magellan_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderMagellan* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_magellan_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_magellan_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_magellan_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_magellan_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_magellan_stop(void* context) {
@@ -397,7 +397,7 @@ uint8_t subghz_protocol_decoder_magellan_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_magellan_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_magellan_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -406,22 +406,14 @@ bool subghz_protocol_decoder_magellan_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_magellan_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_magellan_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderMagellan* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_magellan_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_magellan_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_magellan_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/magellan.h b/lib/subghz/protocols/magellan.h
index a179c9cb4b..e0fb7ca52a 100644
--- a/lib/subghz/protocols/magellan.h
+++ b/lib/subghz/protocols/magellan.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_magellan_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderMagellan instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_magellan_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_magellan_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_magellan_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_magellan_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_magellan_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_magellan_serialize(
  * Deserialize data SubGhzProtocolDecoderMagellan.
  * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_magellan_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_magellan_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/marantec.c b/lib/subghz/protocols/marantec.c
index d557c29b0b..fc4aa0dca4 100644
--- a/lib/subghz/protocols/marantec.c
+++ b/lib/subghz/protocols/marantec.c
@@ -188,18 +188,17 @@ static void subghz_protocol_marantec_remote_controller(SubGhzBlockGeneric* insta
     instance->serial = ((instance->data >> 12) & 0xFFFFFF00) | ((instance->data >> 8) & 0xFF);
 }
 
-bool subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderMarantec* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_marantec_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_marantec_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
@@ -209,11 +208,9 @@ bool subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat*
         subghz_protocol_marantec_remote_controller(&instance->generic);
         subghz_protocol_encoder_marantec_get_upload(instance);
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_marantec_stop(void* context) {
@@ -346,7 +343,7 @@ uint8_t subghz_protocol_decoder_marantec_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_marantec_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_marantec_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -355,22 +352,14 @@ bool subghz_protocol_decoder_marantec_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_marantec_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_marantec_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderMarantec* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_marantec_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_marantec_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/marantec.h b/lib/subghz/protocols/marantec.h
index e330ccf16b..485c563b2f 100644
--- a/lib/subghz/protocols/marantec.h
+++ b/lib/subghz/protocols/marantec.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_marantec_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderMarantec instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_marantec_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_marantec_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_marantec_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_marantec_serialize(
  * Deserialize data SubGhzProtocolDecoderMarantec.
  * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_marantec_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_marantec_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/megacode.c b/lib/subghz/protocols/megacode.c
index 05b5b6894a..ba58bc445b 100644
--- a/lib/subghz/protocols/megacode.c
+++ b/lib/subghz/protocols/megacode.c
@@ -175,31 +175,31 @@ static bool subghz_protocol_encoder_megacode_get_upload(SubGhzProtocolEncoderMeg
     return true;
 }
 
-bool subghz_protocol_encoder_megacode_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_megacode_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderMegaCode* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_megacode_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_megacode_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_megacode_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_megacode_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_megacode_stop(void* context) {
@@ -381,7 +381,7 @@ uint8_t subghz_protocol_decoder_megacode_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_megacode_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_megacode_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -390,22 +390,14 @@ bool subghz_protocol_decoder_megacode_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_megacode_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_megacode_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderMegaCode* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_megacode_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_megacode_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_megacode_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/megacode.h b/lib/subghz/protocols/megacode.h
index e31434fa30..616ecdf64e 100644
--- a/lib/subghz/protocols/megacode.h
+++ b/lib/subghz/protocols/megacode.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_megacode_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderMegaCode instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_megacode_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_megacode_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_megacode_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_megacode_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_megacode_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_megacode_serialize(
  * Deserialize data SubGhzProtocolDecoderMegaCode.
  * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_megacode_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_megacode_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/nero_radio.c b/lib/subghz/protocols/nero_radio.c
index c8126b1e15..d7731dca67 100644
--- a/lib/subghz/protocols/nero_radio.c
+++ b/lib/subghz/protocols/nero_radio.c
@@ -154,31 +154,31 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderNeroRadio* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_nero_radio_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_nero_radio_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_nero_radio_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_nero_radio_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_nero_radio_stop(void* context) {
@@ -343,7 +343,7 @@ uint8_t subghz_protocol_decoder_nero_radio_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_nero_radio_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nero_radio_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -352,22 +352,14 @@ bool subghz_protocol_decoder_nero_radio_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderNeroRadio* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_nero_radio_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_nero_radio_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_nero_radio_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/nero_radio.h b/lib/subghz/protocols/nero_radio.h
index 361da6173c..0598aee6cc 100644
--- a/lib/subghz/protocols/nero_radio.h
+++ b/lib/subghz/protocols/nero_radio.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_nero_radio_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderNeroRadio instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_nero_radio_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nero_radio_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nero_radio_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_nero_radio_serialize(
  * Deserialize data SubGhzProtocolDecoderNeroRadio.
  * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/nero_sketch.c b/lib/subghz/protocols/nero_sketch.c
index b124b717bd..09cd0255ae 100644
--- a/lib/subghz/protocols/nero_sketch.c
+++ b/lib/subghz/protocols/nero_sketch.c
@@ -148,31 +148,31 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderNeroSketch* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_nero_sketch_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_nero_sketch_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_nero_sketch_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_nero_sketch_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_nero_sketch_stop(void* context) {
@@ -328,7 +328,7 @@ uint8_t subghz_protocol_decoder_nero_sketch_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_nero_sketch_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nero_sketch_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -337,22 +337,14 @@ bool subghz_protocol_decoder_nero_sketch_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderNeroSketch* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_nero_sketch_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_nero_sketch_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_nero_sketch_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/nero_sketch.h b/lib/subghz/protocols/nero_sketch.h
index ac87fb00a6..b557772d20 100644
--- a/lib/subghz/protocols/nero_sketch.h
+++ b/lib/subghz/protocols/nero_sketch.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_nero_sketch_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderNeroSketch instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_nero_sketch_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nero_sketch_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nero_sketch_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_nero_sketch_serialize(
  * Deserialize data SubGhzProtocolDecoderNeroSketch.
  * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/nice_flo.c b/lib/subghz/protocols/nice_flo.c
index a57d5f4da5..af81d9f905 100644
--- a/lib/subghz/protocols/nice_flo.c
+++ b/lib/subghz/protocols/nice_flo.c
@@ -129,13 +129,14 @@ static bool subghz_protocol_encoder_nice_flo_get_upload(SubGhzProtocolEncoderNic
     return true;
 }
 
-bool subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderNiceFlo* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit <
@@ -143,19 +144,21 @@ bool subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat*
            (instance->generic.data_count_bit >
             2 * subghz_protocol_nice_flo_const.min_count_bit_for_found)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_nice_flo_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_nice_flo_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_nice_flo_stop(void* context) {
@@ -280,7 +283,7 @@ uint8_t subghz_protocol_decoder_nice_flo_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_nice_flo_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flo_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -289,12 +292,14 @@ bool subghz_protocol_decoder_nice_flo_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderNiceFlo* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit <
@@ -302,9 +307,9 @@ bool subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat*
            (instance->generic.data_count_bit >
             2 * subghz_protocol_nice_flo_const.min_count_bit_for_found)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/nice_flo.h b/lib/subghz/protocols/nice_flo.h
index e382e61461..9a4b53d127 100644
--- a/lib/subghz/protocols/nice_flo.h
+++ b/lib/subghz/protocols/nice_flo.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_nice_flo_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderNiceFlo instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_nice_flo_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nice_flo_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flo_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_nice_flo_serialize(
  * Deserialize data SubGhzProtocolDecoderNiceFlo.
  * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/nice_flor_s.c b/lib/subghz/protocols/nice_flor_s.c
index 135bd49728..dbdb4c8b5d 100644
--- a/lib/subghz/protocols/nice_flor_s.c
+++ b/lib/subghz/protocols/nice_flor_s.c
@@ -306,12 +306,14 @@ static void subghz_protocol_encoder_nice_flor_s_get_upload(
     instance->encoder.size_upload = index;
 }
 
-bool subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderNiceFlorS* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -353,7 +355,7 @@ bool subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperForma
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -573,9 +575,10 @@ bool subghz_protocol_nice_flor_s_create_data(
         }
     }
 
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
-    return res;
+    return res == SubGhzProtocolStatusOk;
 }
 
 void* subghz_protocol_decoder_nice_flor_s_alloc(SubGhzEnvironment* environment) {
@@ -765,51 +768,55 @@ uint8_t subghz_protocol_decoder_nice_flor_s_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_nice_flor_s_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flor_s_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderNiceFlorS* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
-        if(res &&
+        if((ret == SubGhzProtocolStatusOk) &&
            !flipper_format_write_uint32(flipper_format, "Data", (uint32_t*)&instance->data, 1)) {
             FURI_LOG_E(TAG, "Unable to add Data");
-            res = false;
+            ret = SubGhzProtocolStatusErrorParserOthers;
         }
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderNiceFlorS* instance = context;
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if((instance->generic.data_count_bit !=
             subghz_protocol_nice_flor_s_const.min_count_bit_for_found) &&
            (instance->generic.data_count_bit != NICE_ONE_COUNT_BIT)) {
             FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
             break;
         }
         if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
             if(!flipper_format_rewind(flipper_format)) {
                 FURI_LOG_E(TAG, "Rewind error");
+                ret = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             uint32_t temp = 0;
             if(!flipper_format_read_uint32(flipper_format, "Data", (uint32_t*)&temp, 1)) {
                 FURI_LOG_E(TAG, "Missing Data");
+                ret = SubGhzProtocolStatusErrorParserOthers;
                 break;
             }
             instance->data = (uint64_t)temp;
         }
-
-        ret = true;
     } while(false);
     return ret;
 }
diff --git a/lib/subghz/protocols/nice_flor_s.h b/lib/subghz/protocols/nice_flor_s.h
index 3b22db304b..679b318124 100644
--- a/lib/subghz/protocols/nice_flor_s.h
+++ b/lib/subghz/protocols/nice_flor_s.h
@@ -38,7 +38,8 @@ void subghz_protocol_encoder_nice_flor_s_free(void* context);
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -114,9 +115,9 @@ uint8_t subghz_protocol_decoder_nice_flor_s_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nice_flor_s_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flor_s_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -125,9 +126,10 @@ bool subghz_protocol_decoder_nice_flor_s_serialize(
  * Deserialize data SubGhzProtocolDecoderNiceFlorS.
  * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/phoenix_v2.c b/lib/subghz/protocols/phoenix_v2.c
index b3d6f1e98f..4ed9766ef6 100644
--- a/lib/subghz/protocols/phoenix_v2.c
+++ b/lib/subghz/protocols/phoenix_v2.c
@@ -132,31 +132,31 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderPhoenix_V2* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_phoenix_v2_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_phoenix_v2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_phoenix_v2_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_phoenix_v2_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_phoenix_v2_stop(void* context) {
@@ -293,7 +293,7 @@ uint8_t subghz_protocol_decoder_phoenix_v2_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_phoenix_v2_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_phoenix_v2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -302,22 +302,14 @@ bool subghz_protocol_decoder_phoenix_v2_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderPhoenix_V2* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_phoenix_v2_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_phoenix_v2_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/phoenix_v2.h b/lib/subghz/protocols/phoenix_v2.h
index 48487535e7..0724de1f09 100644
--- a/lib/subghz/protocols/phoenix_v2.h
+++ b/lib/subghz/protocols/phoenix_v2.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_phoenix_v2_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_phoenix_v2_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_phoenix_v2_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_phoenix_v2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_phoenix_v2_serialize(
  * Deserialize data SubGhzProtocolDecoderPhoenix_V2.
  * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/power_smart.c b/lib/subghz/protocols/power_smart.c
index 1e8d10e952..d03282f73a 100644
--- a/lib/subghz/protocols/power_smart.c
+++ b/lib/subghz/protocols/power_smart.c
@@ -192,18 +192,17 @@ static void subghz_protocol_power_smart_remote_controller(SubGhzBlockGeneric* in
     instance->cnt = ((instance->data >> 49) & 0x3F);
 }
 
-bool subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderPowerSmart* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_power_smart_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_power_smart_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
@@ -213,11 +212,9 @@ bool subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperForma
         subghz_protocol_power_smart_remote_controller(&instance->generic);
         subghz_protocol_encoder_power_smart_get_upload(instance);
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_power_smart_stop(void* context) {
@@ -345,7 +342,7 @@ uint8_t subghz_protocol_decoder_power_smart_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_power_smart_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_power_smart_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -354,22 +351,14 @@ bool subghz_protocol_decoder_power_smart_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderPowerSmart* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_power_smart_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_power_smart_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_power_smart_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/power_smart.h b/lib/subghz/protocols/power_smart.h
index 806729f8e9..5687cf8b1b 100644
--- a/lib/subghz/protocols/power_smart.h
+++ b/lib/subghz/protocols/power_smart.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_power_smart_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderPowerSmart instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_power_smart_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_power_smart_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_power_smart_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_power_smart_serialize(
  * Deserialize data SubGhzProtocolDecoderPowerSmart.
  * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/princeton.c b/lib/subghz/protocols/princeton.c
index 7fc8f6524d..aa15b8b41c 100644
--- a/lib/subghz/protocols/princeton.c
+++ b/lib/subghz/protocols/princeton.c
@@ -141,39 +141,41 @@ static bool
     return true;
 }
 
-bool subghz_protocol_encoder_princeton_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_princeton_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderPrinceton* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_princeton_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_princeton_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorParserTe;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_princeton_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_princeton_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_princeton_stop(void* context) {
@@ -308,46 +310,48 @@ uint8_t subghz_protocol_decoder_princeton_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_princeton_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_princeton_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderPrinceton* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
-    if(res && !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
         FURI_LOG_E(TAG, "Unable to add TE");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserTe;
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_princeton_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_princeton_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderPrinceton* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_princeton_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_princeton_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
             break;
         }
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_decoder_princeton_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/princeton.h b/lib/subghz/protocols/princeton.h
index a2a11292e3..7c775292d5 100644
--- a/lib/subghz/protocols/princeton.h
+++ b/lib/subghz/protocols/princeton.h
@@ -32,9 +32,10 @@ void subghz_protocol_encoder_princeton_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderPrinceton instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_princeton_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_princeton_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -88,9 +89,9 @@ uint8_t subghz_protocol_decoder_princeton_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_princeton_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_princeton_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -99,9 +100,10 @@ bool subghz_protocol_decoder_princeton_serialize(
  * Deserialize data SubGhzProtocolDecoderPrinceton.
  * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_princeton_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_princeton_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/raw.c b/lib/subghz/protocols/raw.c
index 01a229047c..eaad78b91c 100644
--- a/lib/subghz/protocols/raw.c
+++ b/lib/subghz/protocols/raw.c
@@ -259,12 +259,13 @@ void subghz_protocol_decoder_raw_feed(void* context, bool level, uint32_t durati
     }
 }
 
-bool subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     UNUSED(context);
     UNUSED(flipper_format);
     //ToDo stub, for backwards compatibility
-    return true;
+    return SubGhzProtocolStatusOk;
 }
 
 void subghz_protocol_decoder_raw_get_string(void* context, FuriString* output) {
@@ -342,25 +343,32 @@ void subghz_protocol_raw_gen_fff_data(FlipperFormat* flipper_format, const char*
     } while(false);
 }
 
-bool subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderRAW* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     FuriString* temp_str;
     temp_str = furi_string_alloc();
     do {
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         if(!flipper_format_read_string(flipper_format, "File_name", temp_str)) {
             FURI_LOG_E(TAG, "Missing File_name");
+            res = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         furi_string_set(instance->file_name, temp_str);
 
-        res = subghz_protocol_encoder_raw_worker_init(instance);
+        if(!subghz_protocol_encoder_raw_worker_init(instance)) {
+            res = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        res = SubGhzProtocolStatusOk;
     } while(false);
     furi_string_free(temp_str);
     return res;
diff --git a/lib/subghz/protocols/raw.h b/lib/subghz/protocols/raw.h
index 44c7faec5f..4f67a4e2f2 100644
--- a/lib/subghz/protocols/raw.h
+++ b/lib/subghz/protocols/raw.h
@@ -73,9 +73,10 @@ void subghz_protocol_decoder_raw_feed(void* context, bool level, uint32_t durati
  * Deserialize data SubGhzProtocolDecoderRAW.
  * @param context Pointer to a SubGhzProtocolDecoderRAW instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
@@ -132,9 +133,10 @@ void subghz_protocol_raw_gen_fff_data(FlipperFormat* flipper_format, const char*
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderRAW instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting the level and duration of the upload to be loaded into DMA.
diff --git a/lib/subghz/protocols/scher_khan.c b/lib/subghz/protocols/scher_khan.c
index a5de7d04b4..b68e3c869d 100644
--- a/lib/subghz/protocols/scher_khan.c
+++ b/lib/subghz/protocols/scher_khan.c
@@ -249,7 +249,7 @@ uint8_t subghz_protocol_decoder_scher_khan_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_scher_khan_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_scher_khan_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -258,7 +258,8 @@ bool subghz_protocol_decoder_scher_khan_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderScherKhan* instance = context;
     return subghz_block_generic_deserialize(&instance->generic, flipper_format);
diff --git a/lib/subghz/protocols/scher_khan.h b/lib/subghz/protocols/scher_khan.h
index b7e84ea1f3..58545069cf 100644
--- a/lib/subghz/protocols/scher_khan.h
+++ b/lib/subghz/protocols/scher_khan.h
@@ -50,9 +50,9 @@ uint8_t subghz_protocol_decoder_scher_khan_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderScherKhan instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_scher_khan_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_scher_khan_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -61,9 +61,10 @@ bool subghz_protocol_decoder_scher_khan_serialize(
  * Deserialize data SubGhzProtocolDecoderScherKhan.
  * @param context Pointer to a SubGhzProtocolDecoderScherKhan instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/secplus_v1.c b/lib/subghz/protocols/secplus_v1.c
index 3ef95db36d..55373cc217 100644
--- a/lib/subghz/protocols/secplus_v1.c
+++ b/lib/subghz/protocols/secplus_v1.c
@@ -264,18 +264,17 @@ static bool subghz_protocol_secplus_v1_encode(SubGhzProtocolEncoderSecPlus_v1* i
     return true;
 }
 
-bool subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderSecPlus_v1* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           2 * subghz_protocol_secplus_v1_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            2 * subghz_protocol_secplus_v1_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         //optional parameter parameter
@@ -283,9 +282,12 @@ bool subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
         if(!subghz_protocol_secplus_v1_encode(instance)) {
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!subghz_protocol_encoder_secplus_v1_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            ;
             break;
         }
 
@@ -295,15 +297,14 @@ bool subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat
         }
         if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to add Key");
+            ret = SubGhzProtocolStatusErrorParserKey;
             break;
         }
 
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_secplus_v1_stop(void* context) {
@@ -516,7 +517,7 @@ uint8_t subghz_protocol_decoder_secplus_v1_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_secplus_v1_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v1_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -525,22 +526,14 @@ bool subghz_protocol_decoder_secplus_v1_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderSecPlus_v1* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           2 * subghz_protocol_secplus_v1_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        2 * subghz_protocol_secplus_v1_const.min_count_bit_for_found);
 }
 
 bool subghz_protocol_secplus_v1_check_fixed(uint32_t fixed) {
diff --git a/lib/subghz/protocols/secplus_v1.h b/lib/subghz/protocols/secplus_v1.h
index 99480b62b5..3490f2ca54 100644
--- a/lib/subghz/protocols/secplus_v1.h
+++ b/lib/subghz/protocols/secplus_v1.h
@@ -27,9 +27,10 @@ void subghz_protocol_encoder_secplus_v1_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -83,9 +84,9 @@ uint8_t subghz_protocol_decoder_secplus_v1_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_secplus_v1_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v1_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -94,9 +95,10 @@ bool subghz_protocol_decoder_secplus_v1_serialize(
  * Deserialize data SubGhzProtocolDecoderSecPlus_v1.
  * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Validation of fixed parts SubGhzProtocolDecoderSecPlus_v1.
diff --git a/lib/subghz/protocols/secplus_v2.c b/lib/subghz/protocols/secplus_v2.c
index 9f8c316542..a55930552b 100644
--- a/lib/subghz/protocols/secplus_v2.c
+++ b/lib/subghz/protocols/secplus_v2.c
@@ -504,24 +504,24 @@ static void
     instance->encoder.size_upload = index;
 }
 
-bool subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderSecPlus_v2* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_secplus_v2_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_secplus_v2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(
                flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Secplus_packet_1");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
@@ -542,6 +542,7 @@ bool subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat
         }
         if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to add Key");
+            ret = SubGhzProtocolStatusErrorParserKey;
             break;
         }
 
@@ -551,15 +552,14 @@ bool subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat
         if(!flipper_format_update_hex(
                flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Unable to add Secplus_packet_1");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
 
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_secplus_v2_stop(void* context) {
@@ -600,19 +600,20 @@ bool subghz_protocol_secplus_v2_create_data(
     instance->generic.data_count_bit =
         (uint8_t)subghz_protocol_secplus_v2_const.min_count_bit_for_found;
     subghz_protocol_secplus_v2_encode(instance);
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
     uint8_t key_data[sizeof(uint64_t)] = {0};
     for(size_t i = 0; i < sizeof(uint64_t); i++) {
         key_data[sizeof(uint64_t) - i - 1] = (instance->secplus_packet_1 >> (i * 8)) & 0xFF;
     }
 
-    if(res &&
+    if((res == SubGhzProtocolStatusOk) &&
        !flipper_format_write_hex(flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
         FURI_LOG_E(TAG, "Unable to add Secplus_packet_1");
-        res = false;
+        res = SubGhzProtocolStatusError;
     }
-    return res;
+    return res == SubGhzProtocolStatusOk;
 }
 
 void* subghz_protocol_decoder_secplus_v2_alloc(SubGhzEnvironment* environment) {
@@ -755,58 +756,59 @@ uint8_t subghz_protocol_decoder_secplus_v2_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_secplus_v2_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderSecPlus_v2* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
     uint8_t key_data[sizeof(uint64_t)] = {0};
     for(size_t i = 0; i < sizeof(uint64_t); i++) {
         key_data[sizeof(uint64_t) - i - 1] = (instance->secplus_packet_1 >> (i * 8)) & 0xFF;
     }
 
-    if(res &&
+    if((ret == SubGhzProtocolStatusOk) &&
        !flipper_format_write_hex(flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
         FURI_LOG_E(TAG, "Unable to add Secplus_packet_1");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserOthers;
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderSecPlus_v2* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_secplus_v2_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_secplus_v2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(
                flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
             FURI_LOG_E(TAG, "Missing Secplus_packet_1");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
             instance->secplus_packet_1 = instance->secplus_packet_1 << 8 | key_data[i];
         }
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_decoder_secplus_v2_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/secplus_v2.h b/lib/subghz/protocols/secplus_v2.h
index bea8cdb5d9..0eea732af1 100644
--- a/lib/subghz/protocols/secplus_v2.h
+++ b/lib/subghz/protocols/secplus_v2.h
@@ -27,9 +27,10 @@ void subghz_protocol_encoder_secplus_v2_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -102,9 +103,9 @@ uint8_t subghz_protocol_decoder_secplus_v2_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_secplus_v2_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v2_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -113,9 +114,10 @@ bool subghz_protocol_decoder_secplus_v2_serialize(
  * Deserialize data SubGhzProtocolDecoderSecPlus_v2.
  * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/smc5326.c b/lib/subghz/protocols/smc5326.c
index 9c9b5d4fd7..bfb36b76a9 100644
--- a/lib/subghz/protocols/smc5326.c
+++ b/lib/subghz/protocols/smc5326.c
@@ -155,39 +155,41 @@ static bool subghz_protocol_encoder_smc5326_get_upload(SubGhzProtocolEncoderSMC5
     return true;
 }
 
-bool subghz_protocol_encoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderSMC5326* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_smc5326_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_smc5326_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorParserTe;
             break;
         }
         //optional parameter parameter
         flipper_format_read_uint32(
             flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
 
-        if(!subghz_protocol_encoder_smc5326_get_upload(instance)) break;
+        if(!subghz_protocol_encoder_smc5326_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
         instance->encoder.is_running = true;
-
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_encoder_smc5326_stop(void* context) {
@@ -313,46 +315,48 @@ uint8_t subghz_protocol_decoder_smc5326_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_smc5326_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_smc5326_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderSMC5326* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
-    if(res && !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
         FURI_LOG_E(TAG, "Unable to add TE");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserTe;
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderSMC5326* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_smc5326_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_smc5326_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
             FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
             break;
         }
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 static void subghz_protocol_smc5326_get_event_serialize(uint8_t event, FuriString* output) {
diff --git a/lib/subghz/protocols/smc5326.h b/lib/subghz/protocols/smc5326.h
index ddc954bd57..911226cf9b 100644
--- a/lib/subghz/protocols/smc5326.h
+++ b/lib/subghz/protocols/smc5326.h
@@ -28,9 +28,10 @@ void subghz_protocol_encoder_smc5326_free(void* context);
  * Deserialize and generating an upload to send.
  * @param context Pointer to a SubGhzProtocolEncoderSMC5326 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_encoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -84,9 +85,9 @@ uint8_t subghz_protocol_decoder_smc5326_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_smc5326_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_smc5326_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -95,9 +96,10 @@ bool subghz_protocol_decoder_smc5326_serialize(
  * Deserialize data SubGhzProtocolDecoderSMC5326.
  * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/somfy_keytis.c b/lib/subghz/protocols/somfy_keytis.c
index 1bcd89f42f..dd860a61da 100644
--- a/lib/subghz/protocols/somfy_keytis.c
+++ b/lib/subghz/protocols/somfy_keytis.c
@@ -192,7 +192,8 @@ bool subghz_protocol_somfy_keytis_create_data(
     instance->generic.data_count_bit = 80;
     bool res = subghz_protocol_somfy_keytis_gen_data(instance, btn);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -390,12 +391,14 @@ static bool subghz_protocol_encoder_somfy_keytis_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderSomfyKeytis* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -421,7 +424,7 @@ bool subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperForm
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -729,37 +732,39 @@ uint8_t subghz_protocol_decoder_somfy_keytis_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_somfy_keytis_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_keytis_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
     furi_assert(context);
     SubGhzProtocolDecoderSomfyKeytis* instance = context;
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
-    if(res && !flipper_format_write_uint32(
-                  flipper_format, "Duration_Counter", &instance->press_duration_counter, 1)) {
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(
+           flipper_format, "Duration_Counter", &instance->press_duration_counter, 1)) {
         FURI_LOG_E(TAG, "Unable to add Duration_Counter");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserOthers;
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderSomfyKeytis* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            FURI_LOG_E(TAG, "Deserialize error");
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_somfy_keytis_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_somfy_keytis_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
             break;
         }
         if(!flipper_format_rewind(flipper_format)) {
             FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
         if(!flipper_format_read_uint32(
@@ -768,12 +773,12 @@ bool subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperForm
                (uint32_t*)&instance->press_duration_counter,
                1)) {
             FURI_LOG_E(TAG, "Missing Duration_Counter");
+            ret = SubGhzProtocolStatusErrorParserOthers;
             break;
         }
-        res = true;
     } while(false);
 
-    return res;
+    return ret;
 }
 
 void subghz_protocol_decoder_somfy_keytis_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/somfy_keytis.h b/lib/subghz/protocols/somfy_keytis.h
index b08da36416..0e339c8891 100644
--- a/lib/subghz/protocols/somfy_keytis.h
+++ b/lib/subghz/protocols/somfy_keytis.h
@@ -48,7 +48,8 @@ bool subghz_protocol_somfy_keytis_create_data(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -102,9 +103,9 @@ uint8_t subghz_protocol_decoder_somfy_keytis_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_somfy_keytis_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_keytis_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -113,9 +114,10 @@ bool subghz_protocol_decoder_somfy_keytis_serialize(
  * Deserialize data SubGhzProtocolDecoderSomfyKeytis.
  * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/somfy_telis.c b/lib/subghz/protocols/somfy_telis.c
index 5d6b1c6f3c..0294a19220 100644
--- a/lib/subghz/protocols/somfy_telis.c
+++ b/lib/subghz/protocols/somfy_telis.c
@@ -252,7 +252,8 @@ bool subghz_protocol_somfy_telis_create_data(
     instance->generic.data_count_bit = 56;
     bool res = subghz_protocol_somfy_telis_gen_data(instance, btn, true);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -390,12 +391,14 @@ static bool subghz_protocol_encoder_somfy_telis_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderSomfyTelis* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -421,7 +424,7 @@ bool subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperForma
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -718,7 +721,7 @@ uint8_t subghz_protocol_decoder_somfy_telis_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_somfy_telis_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_telis_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -727,22 +730,14 @@ bool subghz_protocol_decoder_somfy_telis_serialize(
     return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 }
 
-bool subghz_protocol_decoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderSomfyTelis* instance = context;
-    bool ret = false;
-    do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
-            break;
-        }
-        if(instance->generic.data_count_bit !=
-           subghz_protocol_somfy_telis_const.min_count_bit_for_found) {
-            FURI_LOG_E(TAG, "Wrong number of bits in key");
-            break;
-        }
-        ret = true;
-    } while(false);
-    return ret;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_somfy_telis_const.min_count_bit_for_found);
 }
 
 void subghz_protocol_decoder_somfy_telis_get_string(void* context, FuriString* output) {
diff --git a/lib/subghz/protocols/somfy_telis.h b/lib/subghz/protocols/somfy_telis.h
index bca58b64b9..36f6c70b5c 100644
--- a/lib/subghz/protocols/somfy_telis.h
+++ b/lib/subghz/protocols/somfy_telis.h
@@ -56,7 +56,8 @@ bool subghz_protocol_somfy_telis_create_data(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -110,9 +111,9 @@ uint8_t subghz_protocol_decoder_somfy_telis_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_somfy_telis_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_telis_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -121,9 +122,10 @@ bool subghz_protocol_decoder_somfy_telis_serialize(
  * Deserialize data SubGhzProtocolDecoderSomfyTelis.
  * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/protocols/star_line.c b/lib/subghz/protocols/star_line.c
index e09e7e951b..5f96d3fcbc 100644
--- a/lib/subghz/protocols/star_line.c
+++ b/lib/subghz/protocols/star_line.c
@@ -221,7 +221,8 @@ bool subghz_protocol_star_line_create_data(
     instance->generic.data_count_bit = 64;
     bool res = subghz_protocol_star_line_gen_data(instance, btn);
     if(res) {
-        res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
     }
     return res;
 }
@@ -280,12 +281,14 @@ static bool subghz_protocol_encoder_star_line_get_upload(
     return true;
 }
 
-bool subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolEncoderStarLine* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -323,7 +326,7 @@ bool subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat*
 
         instance->encoder.is_running = true;
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
@@ -702,7 +705,7 @@ uint8_t subghz_protocol_decoder_star_line_get_hash_data(void* context) {
         &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
 }
 
-bool subghz_protocol_decoder_star_line_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_star_line_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset) {
@@ -710,27 +713,32 @@ bool subghz_protocol_decoder_star_line_serialize(
     SubGhzProtocolDecoderStarLine* instance = context;
     subghz_protocol_star_line_check_remote_controller(
         &instance->generic, instance->keystore, &instance->manufacture_name);
-    bool res = subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
 
-    if(res && !flipper_format_write_string_cstr(
-                  flipper_format, "Manufacture", instance->manufacture_name)) {
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_string_cstr(
+           flipper_format, "Manufacture", instance->manufacture_name)) {
         FURI_LOG_E(TAG, "Unable to add manufacture name");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserOthers;
     }
-    if(res && instance->generic.data_count_bit !=
-                  subghz_protocol_star_line_const.min_count_bit_for_found) {
+    if((ret == SubGhzProtocolStatusOk) &&
+       instance->generic.data_count_bit !=
+           subghz_protocol_star_line_const.min_count_bit_for_found) {
         FURI_LOG_E(TAG, "Wrong number of bits in key");
-        res = false;
+        ret = SubGhzProtocolStatusErrorParserOthers;
     }
-    return res;
+    return ret;
 }
 
-bool subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format) {
     furi_assert(context);
     SubGhzProtocolDecoderStarLine* instance = context;
-    bool res = false;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
     do {
-        if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
             FURI_LOG_E(TAG, "Deserialize error");
             break;
         }
@@ -744,7 +752,7 @@ bool subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat*
             FURI_LOG_D(TAG, "DECODER: Missing Manufacture");
         }
 
-        res = true;
+        res = SubGhzProtocolStatusOk;
     } while(false);
 
     return res;
diff --git a/lib/subghz/protocols/star_line.h b/lib/subghz/protocols/star_line.h
index e8873d41ae..901b82f7ca 100644
--- a/lib/subghz/protocols/star_line.h
+++ b/lib/subghz/protocols/star_line.h
@@ -54,7 +54,8 @@ bool subghz_protocol_star_line_create_data(
  * @param flipper_format Pointer to a FlipperFormat instance
  * @return true On success
  */
-bool subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Forced transmission stop.
@@ -108,9 +109,9 @@ uint8_t subghz_protocol_decoder_star_line_get_hash_data(void* context);
  * @param context Pointer to a SubGhzProtocolDecoderStarLine instance
  * @param flipper_format Pointer to a FlipperFormat instance
  * @param preset The modulation on which the signal was received, SubGhzRadioPreset
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_star_line_serialize(
+SubGhzProtocolStatus subghz_protocol_decoder_star_line_serialize(
     void* context,
     FlipperFormat* flipper_format,
     SubGhzRadioPreset* preset);
@@ -119,9 +120,10 @@ bool subghz_protocol_decoder_star_line_serialize(
  * Deserialize data SubGhzProtocolDecoderStarLine.
  * @param context Pointer to a SubGhzProtocolDecoderStarLine instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
 
 /**
  * Getting a textual representation of the received data.
diff --git a/lib/subghz/transmitter.c b/lib/subghz/transmitter.c
index 8507ee054b..81be143b53 100644
--- a/lib/subghz/transmitter.c
+++ b/lib/subghz/transmitter.c
@@ -47,9 +47,10 @@ bool subghz_transmitter_stop(SubGhzTransmitter* instance) {
     return ret;
 }
 
-bool subghz_transmitter_deserialize(SubGhzTransmitter* instance, FlipperFormat* flipper_format) {
+SubGhzProtocolStatus
+    subghz_transmitter_deserialize(SubGhzTransmitter* instance, FlipperFormat* flipper_format) {
     furi_assert(instance);
-    bool ret = false;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
     if(instance->protocol && instance->protocol->encoder &&
        instance->protocol->encoder->deserialize) {
         ret =
diff --git a/lib/subghz/transmitter.h b/lib/subghz/transmitter.h
index cce98a463a..a1c4cda08f 100644
--- a/lib/subghz/transmitter.h
+++ b/lib/subghz/transmitter.h
@@ -39,9 +39,10 @@ bool subghz_transmitter_stop(SubGhzTransmitter* instance);
  * Deserialize and generating an upload to send.
  * @param instance Pointer to a SubGhzTransmitter instance
  * @param flipper_format Pointer to a FlipperFormat instance
- * @return true On success
+ * @return status
  */
-bool subghz_transmitter_deserialize(SubGhzTransmitter* instance, FlipperFormat* flipper_format);
+SubGhzProtocolStatus
+    subghz_transmitter_deserialize(SubGhzTransmitter* instance, FlipperFormat* flipper_format);
 
 /**
  * Getting the level and duration of the upload to be loaded into DMA.
diff --git a/lib/subghz/types.h b/lib/subghz/types.h
index 9d121dc3c9..e0ed956541 100644
--- a/lib/subghz/types.h
+++ b/lib/subghz/types.h
@@ -29,14 +29,36 @@ typedef struct {
     size_t data_size;
 } SubGhzRadioPreset;
 
+typedef enum {
+    SubGhzProtocolStatusOk = 0,
+    // Errors
+    SubGhzProtocolStatusError = (-1), ///< General unclassified error
+    // Serialize/De-serialize
+    SubGhzProtocolStatusErrorParserHeader = (-2), ///< Missing or invalid file header
+    SubGhzProtocolStatusErrorParserFrequency = (-3), ///< Missing `Frequency`
+    SubGhzProtocolStatusErrorParserPreset = (-4), ///< Missing `Preset`
+    SubGhzProtocolStatusErrorParserCustomPreset = (-5), ///< Missing `Custom_preset_module`
+    SubGhzProtocolStatusErrorParserProtocolName = (-6), ///< Missing `Protocol` name
+    SubGhzProtocolStatusErrorParserBitCount = (-7), ///< Missing `Bit`
+    SubGhzProtocolStatusErrorParserKey = (-8), ///< Missing `Key`
+    SubGhzProtocolStatusErrorParserTe = (-9), ///< Missing `Te`
+    SubGhzProtocolStatusErrorParserOthers = (-10), ///< Missing some other mandatory keys
+    // Invalid data
+    SubGhzProtocolStatusErrorValueBitCount = (-11), ///< Invalid bit count value
+    // Encoder issue
+    SubGhzProtocolStatusErrorEncoderGetUpload = (-12), ///< Payload encoder failure
+    // Special Values
+    SubGhzProtocolStatusReserved = 0x7FFFFFFF, ///< Prevents enum down-size compiler optimization.
+} SubGhzProtocolStatus;
+
 // Allocator and Deallocator
 typedef void* (*SubGhzAlloc)(SubGhzEnvironment* environment);
 typedef void (*SubGhzFree)(void* context);
 
 // Serialize and Deserialize
-typedef bool (
+typedef SubGhzProtocolStatus (
     *SubGhzSerialize)(void* context, FlipperFormat* flipper_format, SubGhzRadioPreset* preset);
-typedef bool (*SubGhzDeserialize)(void* context, FlipperFormat* flipper_format);
+typedef SubGhzProtocolStatus (*SubGhzDeserialize)(void* context, FlipperFormat* flipper_format);
 
 // Decoder specific
 typedef void (*SubGhzDecoderFeed)(void* decoder, bool level, uint32_t duration);
diff --git a/lib/toolbox/SConscript b/lib/toolbox/SConscript
index da6c1115c0..c01e32a6b3 100644
--- a/lib/toolbox/SConscript
+++ b/lib/toolbox/SConscript
@@ -27,6 +27,7 @@ env.Append(
         File("stream/string_stream.h"),
         File("stream/buffered_file_stream.h"),
         File("protocols/protocol_dict.h"),
+        File("pretty_format.h"),
     ],
 )
 
diff --git a/lib/toolbox/dir_walk.c b/lib/toolbox/dir_walk.c
index e5a3cf32b5..509ceb5b42 100644
--- a/lib/toolbox/dir_walk.c
+++ b/lib/toolbox/dir_walk.c
@@ -83,7 +83,7 @@ static DirWalkResult
                 end = true;
             }
 
-            if((info.flags & FSF_DIRECTORY) && dir_walk->recursive) {
+            if(file_info_is_dir(&info) && dir_walk->recursive) {
                 // step into
                 DirIndexList_push_back(dir_walk->index_list, dir_walk->current_index);
                 dir_walk->current_index = 0;
diff --git a/lib/toolbox/pretty_format.c b/lib/toolbox/pretty_format.c
new file mode 100644
index 0000000000..d5ba10381a
--- /dev/null
+++ b/lib/toolbox/pretty_format.c
@@ -0,0 +1,60 @@
+#include "pretty_format.h"
+
+#include <core/check.h>
+#include <core/core_defines.h>
+
+#define PRETTY_FORMAT_MAX_CANONICAL_DATA_SIZE 256U
+
+void pretty_format_bytes_hex_canonical(
+    FuriString* result,
+    size_t num_places,
+    const char* line_prefix,
+    const uint8_t* data,
+    size_t data_size) {
+    furi_assert(data);
+
+    bool is_truncated = false;
+
+    if(data_size > PRETTY_FORMAT_MAX_CANONICAL_DATA_SIZE) {
+        data_size = PRETTY_FORMAT_MAX_CANONICAL_DATA_SIZE;
+        is_truncated = true;
+    }
+
+    /* Only num_places byte(s) can be on a single line, therefore: */
+    const size_t line_count =
+        data_size / num_places + (data_size % num_places != 0 ? 1 : 0) + (is_truncated ? 2 : 0);
+    /* Line length = Prefix length + 3 * num_places (2 hex digits + space) + 1 * num_places +
+       + 1 pipe character + 1 newline character */
+    const size_t line_length = (line_prefix ? strlen(line_prefix) : 0) + 4 * num_places + 2;
+
+    /* Reserve memory in adance in order to avoid unnecessary reallocs */
+    furi_string_reset(result);
+    furi_string_reserve(result, line_count * line_length);
+
+    for(size_t i = 0; i < data_size; i += num_places) {
+        if(line_prefix) {
+            furi_string_cat(result, line_prefix);
+        }
+
+        const size_t begin_idx = i;
+        const size_t end_idx = MIN(i + num_places, data_size);
+
+        for(size_t j = begin_idx; j < end_idx; j++) {
+            furi_string_cat_printf(result, "%02X ", data[j]);
+        }
+
+        furi_string_push_back(result, '|');
+
+        for(size_t j = begin_idx; j < end_idx; j++) {
+            const char c = data[j];
+            const char sep = ((j < end_idx - 1) ? ' ' : '\n');
+            const char* fmt = ((j < data_size - 1) ? "%c%c" : "%c");
+            furi_string_cat_printf(result, fmt, (c > 0x1f && c < 0x7f) ? c : '.', sep);
+        }
+    }
+
+    if(is_truncated) {
+        furi_string_cat_printf(
+            result, "\n(Data is too big. Showing only the first %zu bytes.)", data_size);
+    }
+}
diff --git a/lib/toolbox/pretty_format.h b/lib/toolbox/pretty_format.h
new file mode 100644
index 0000000000..860528e4cd
--- /dev/null
+++ b/lib/toolbox/pretty_format.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <core/string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PRETTY_FORMAT_FONT_BOLD "\e#"
+#define PRETTY_FORMAT_FONT_MONOSPACE "\e*"
+
+/**
+ * Format a data buffer as a canonical HEX dump
+ * @param [out] result pointer to the output string (must be initialised)
+ * @param [in] num_places the number of bytes on one line (both as HEX and ASCII)
+ * @param [in] line_prefix if not NULL, prepend this string to each line
+ * @param [in] data pointer to the input data buffer
+ * @param [in] data_size input data size
+ */
+void pretty_format_bytes_hex_canonical(
+    FuriString* result,
+    size_t num_places,
+    const char* line_prefix,
+    const uint8_t* data,
+    size_t data_size);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/toolbox/stream/buffered_file_stream.c b/lib/toolbox/stream/buffered_file_stream.c
index 3b20a391c6..3b485e80df 100644
--- a/lib/toolbox/stream/buffered_file_stream.c
+++ b/lib/toolbox/stream/buffered_file_stream.c
@@ -95,6 +95,7 @@ FS_Error buffered_file_stream_get_error(Stream* _stream) {
 
 static void buffered_file_stream_free(BufferedFileStream* stream) {
     furi_assert(stream);
+    buffered_file_stream_sync((Stream*)stream);
     stream_free(stream->file_stream);
     stream_cache_free(stream->cache);
     free(stream);
diff --git a/lib/toolbox/tar/tar_archive.c b/lib/toolbox/tar/tar_archive.c
index 01969b4712..fcfc22a703 100644
--- a/lib/toolbox/tar/tar_archive.c
+++ b/lib/toolbox/tar/tar_archive.c
@@ -344,7 +344,7 @@ bool tar_archive_add_dir(TarArchive* archive, const char* fs_full_path, const ch
                 furi_string_set(element_name, name);
             }
 
-            if(file_info.flags & FSF_DIRECTORY) {
+            if(file_info_is_dir(&file_info)) {
                 success =
                     tar_archive_dir_add_element(archive, furi_string_get_cstr(element_name)) &&
                     tar_archive_add_dir(
diff --git a/scripts/fbt/appmanifest.py b/scripts/fbt/appmanifest.py
index aa03d265b3..64b9f6f39b 100644
--- a/scripts/fbt/appmanifest.py
+++ b/scripts/fbt/appmanifest.py
@@ -321,6 +321,7 @@ def get_app_descr(self, app: FlipperApplication):
         return f"""
     {{.app = {app.entry_point},
      .name = "{app.name}",
+     .appid = "{app.appid}", 
      .stack_size = {app.stack_size},
      .icon = {f"&{app.icon}" if app.icon else "NULL"},
      .flags = {'|'.join(f"FlipperApplicationFlag{flag}" for flag in app.flags)} }}"""