Change shortcut mode for blindsign mode

app/Makefile

@@ -40,7 +40,7 @@ DEFINES += PRODUCTION_BUILD=$(PRODUCTION_BUILD)
 
 include $(CURDIR)/../deps/ledger-zxlib/makefiles/Makefile.app_testing
 
-DEFINES += REVIEW_SCREEN_ENABLED APP_BLINDSIGN_MODE_ENABLED
+DEFINES += APP_BLINDSIGN_MODE_ENABLED
 
 ifndef COIN
 COIN=ALGO

app/src/parser_impl.c

@@ -41,6 +41,24 @@ static parser_error_t _findKey(parser_context_t *c, const char *key);
         counter++;                              \
     }
 
+#define DISPLAY_APP_ITEM(appIdx, len, counter, v)   \
+    if (!app_mode_blindsign()) {                    \
+        for(uint8_t j = 0; j < len; j++) {          \
+            CHECK_ERROR(addItem(appIdx))            \
+            counter++;                              \
+        }                                           \
+    }
+
+#define DISPLAY_COMMON_ITEM(appIdx, len, counter, v)        \
+    if (v->type == TX_APPLICATION && !app_mode_expert()) {  \
+        if (appIdx == IDX_COMMON_SENDER ||                  \
+            appIdx == IDX_COMMON_REKEY_TO) {                \
+            DISPLAY_ITEM(appIdx, len, counter)              \
+        }                                                   \
+    } else {                                                \
+        DISPLAY_ITEM(appIdx, len, counter)                  \
+    }
+
 parser_error_t parser_init_context(parser_context_t *ctx,
                                    const uint8_t *buffer,
                                    uint16_t bufferSize) {
@@ -774,44 +792,44 @@ static parser_error_t _readTxCommonParams(parser_context_t *c, parser_tx_t *v)
 
     CHECK_ERROR(_findKey(c, KEY_COMMON_SENDER))
     CHECK_ERROR(_readBinFixed(c, v->sender, sizeof(v->sender)))
-    DISPLAY_ITEM(IDX_COMMON_SENDER, 1, common_num_items)
+    DISPLAY_COMMON_ITEM(IDX_COMMON_SENDER, 1, common_num_items, v)
 
     if (_findKey(c, KEY_COMMON_LEASE) == parser_ok) {
         CHECK_ERROR(_readBinFixed(c, v->lease, sizeof(v->lease)))
-        DISPLAY_ITEM(IDX_COMMON_LEASE, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_LEASE, 1, common_num_items, v)
     }
 
     if (_findKey(c, KEY_COMMON_REKEY) == parser_ok) {
         CHECK_ERROR(_readBinFixed(c, v->rekey, sizeof(v->rekey)))
-        DISPLAY_ITEM(IDX_COMMON_REKEY_TO, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_REKEY_TO, 1, common_num_items, v)
     }
 
     v->fee = 0;
     if (_findKey(c, KEY_COMMON_FEE) == parser_ok) {
         CHECK_ERROR(_readInteger(c, &v->fee))
     }
-    DISPLAY_ITEM(IDX_COMMON_FEE, 1, common_num_items)
+    DISPLAY_COMMON_ITEM(IDX_COMMON_FEE, 1, common_num_items, v)
 
     if (_findKey(c, KEY_COMMON_GEN_ID) == parser_ok) {
         CHECK_ERROR(_readString(c, (uint8_t*)v->genesisID, sizeof(v->genesisID)))
-        DISPLAY_ITEM(IDX_COMMON_GEN_ID, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_GEN_ID, 1, common_num_items, v)
     }
 
     CHECK_ERROR(_findKey(c, KEY_COMMON_GEN_HASH))
     CHECK_ERROR(_readBinFixed(c, v->genesisHash, sizeof(v->genesisHash)))
-    DISPLAY_ITEM(IDX_COMMON_GEN_HASH, 1, common_num_items)
+    DISPLAY_COMMON_ITEM(IDX_COMMON_GEN_HASH, 1, common_num_items, v)
 
     if (_findKey(c, KEY_COMMON_GROUP_ID) == parser_ok) {
         CHECK_ERROR(_readBinFixed(c, v->groupID, sizeof(v->groupID)))
-        DISPLAY_ITEM(IDX_COMMON_GROUP_ID, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_GROUP_ID, 1, common_num_items, v)
     }
 
     if (_findKey(c, KEY_COMMON_NOTE) == parser_ok) {
         CHECK_ERROR(_readBinSize(c, &v->note_len))
         if(v->note_len > MAX_NOTE_LEN) {
             return parser_unexpected_value;
         }
-        DISPLAY_ITEM(IDX_COMMON_NOTE, 1, common_num_items)
+        DISPLAY_COMMON_ITEM(IDX_COMMON_NOTE, 1, common_num_items, v)
     }
 
     // First and Last valid won't be display --> don't count them
@@ -1050,31 +1068,31 @@ static parser_error_t _readTxApplication(parser_context_t *c, parser_tx_t *v)
     if (_findKey(c, KEY_APP_ID) == parser_ok) {
         CHECK_ERROR(_readInteger(c, &application->id))
     }
-    DISPLAY_ITEM(IDX_APP_ID, 1, tx_num_items)
+    DISPLAY_APP_ITEM(IDX_APP_ID, 1, tx_num_items, v)
 
     if (_findKey(c, KEY_APP_ONCOMPLETION) == parser_ok) {
         CHECK_ERROR(_readInteger(c, &application->oncompletion))
     }
-    DISPLAY_ITEM(IDX_ON_COMPLETION, 1, tx_num_items)
+    DISPLAY_APP_ITEM(IDX_ON_COMPLETION, 1, tx_num_items, v)
 
     if (_findKey(c, KEY_APP_BOXES) == parser_ok) {
         CHECK_ERROR(_readBoxes(c, application->boxes, &application->num_boxes))
-        DISPLAY_ITEM(IDX_BOXES, application->num_boxes, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_BOXES, application->num_boxes, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_FOREIGN_APPS) == parser_ok) {
         CHECK_ERROR(_readArrayU64(c, application->foreign_apps, &application->num_foreign_apps, MAX_FOREIGN_APPS))
-        DISPLAY_ITEM(IDX_FOREIGN_APP, application->num_foreign_apps, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_FOREIGN_APP, application->num_foreign_apps, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_FOREIGN_ASSETS) == parser_ok) {
         CHECK_ERROR(_readArrayU64(c, application->foreign_assets, &application->num_foreign_assets, MAX_FOREIGN_ASSETS))
-        DISPLAY_ITEM(IDX_FOREIGN_ASSET, application->num_foreign_assets, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_FOREIGN_ASSET, application->num_foreign_assets, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_ACCOUNTS) == parser_ok) {
         CHECK_ERROR(_verifyAccounts(c, &application->num_accounts, MAX_ACCT))
-        DISPLAY_ITEM(IDX_ACCOUNTS, application->num_accounts, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_ACCOUNTS, application->num_accounts, tx_num_items, v)
     }
 
     if(application->num_accounts + application->num_foreign_apps + application->num_foreign_assets > ACCT_FOREIGN_LIMIT) {
@@ -1083,7 +1101,7 @@ static parser_error_t _readTxApplication(parser_context_t *c, parser_tx_t *v)
 
     if (_findKey(c, KEY_APP_ARGS) == parser_ok) {
         CHECK_ERROR(_verifyAppArgs(c, application->app_args_len, &application->num_app_args, MAX_ARG))
-        DISPLAY_ITEM(IDX_APP_ARGS, application->num_app_args, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_APP_ARGS, application->num_app_args, tx_num_items, v)
     }
 
     uint16_t app_args_total_len = 0;
@@ -1096,30 +1114,30 @@ static parser_error_t _readTxApplication(parser_context_t *c, parser_tx_t *v)
 
     if (_findKey(c, KEY_APP_GLOBAL_SCHEMA) == parser_ok) {
         CHECK_ERROR(_readStateSchema(c, &application->global_schema))
-        DISPLAY_ITEM(IDX_GLOBAL_SCHEMA, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_GLOBAL_SCHEMA, 1, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_LOCAL_SCHEMA) == parser_ok) {
         CHECK_ERROR(_readStateSchema(c, &application->local_schema))
-        DISPLAY_ITEM(IDX_LOCAL_SCHEMA, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_LOCAL_SCHEMA, 1, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_EXTRA_PAGES) == parser_ok) {
         CHECK_ERROR(_readUInt8(c, &application->extra_pages))
         if (application->extra_pages > 3){
             return parser_too_many_extra_pages;
         }
-        DISPLAY_ITEM(IDX_EXTRA_PAGES, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_EXTRA_PAGES, 1, tx_num_items, v)
     }
 
     if (_findKey(c, KEY_APP_APROG_LEN) == parser_ok) {
         CHECK_ERROR(_getPointerBin(c, &application->aprog, &application->aprog_len))
-        DISPLAY_ITEM(IDX_APPROVE, 1, tx_num_items)
+        DISPLAY_APP_ITEM(IDX_APPROVE, 1, tx_num_items, v)
     }
 
    if (_findKey(c, KEY_APP_CPROG_LEN) == parser_ok) {
        CHECK_ERROR(_getPointerBin(c, &application->cprog, &application->cprog_len))
-       DISPLAY_ITEM(IDX_CLEAR, 1, tx_num_items)
+       DISPLAY_APP_ITEM(IDX_CLEAR, 1, tx_num_items, v)
    }
 
     if (application->id == 0 && application->cprog_len + application->aprog_len > PAGE_LEN *(1+application->extra_pages)){
@@ -1164,10 +1182,13 @@ parser_error_t _read(parser_context_t *c, parser_tx_t *v)
         CHECK_ERROR(_readTxAssetConfig(c, v))
         break;
     case TX_APPLICATION:
-        if (!app_mode_blindsign()) {
+        if (!app_mode_blindsign() && !app_mode_expert()) {
             return parser_blindsign_mode_required;
         }
         CHECK_ERROR(_readTxApplication(c, v))
+        if (app_mode_expert() && !app_mode_blindsign()) {
+            app_mode_skip_blindsign_ui();
+        }
         break;
     default:
         return parser_unknown_transaction;

tests_zemu/package.json

@@ -15,13 +15,15 @@
   ],
   "scripts": {
     "clean": "ts-node tests/pullImageKillOld.ts",
-    "test": "yarn clean && jest --maxConcurrency 2"
+    "test": "yarn clean && jest --maxConcurrency 2",
+    "try": "node try.mjs"
   },
   "dependencies": {
     "@zondax/ledger-algorand": "../js",
     "@zondax/zemu": "^0.53.0"
   },
   "devDependencies": {
+    "@ledgerhq/hw-transport-node-hid": "^6.29.5",
     "@types/jest": "^29.4.0",
     "@types/ledgerhq__hw-transport": "^4.21.4",
     "@typescript-eslint/eslint-plugin": "^7.17.0",