Relayed v3 support

Makefile

@@ -32,8 +32,8 @@ APP_LOAD_PARAMS += $(COMMON_LOAD_PARAMS)
 
 APPNAME      = "MultiversX"
 APPVERSION_M = 1
-APPVERSION_N = 0
-APPVERSION_P = 23
+APPVERSION_N = 1
+APPVERSION_P = 0
 APPVERSION   = $(APPVERSION_M).$(APPVERSION_N).$(APPVERSION_P)
 
 ifeq ($(TARGET_NAME),TARGET_NANOS)

ledger_app.toml

@@ -0,0 +1,8 @@
+[app]
+build_directory = "./"
+sdk = "C"
+devices = ["nanos", "nanox", "nanos+", "stax"]
+
+[tests]
+unit_directory = "./unit-tests/"
+pytest_directory = "./tests/"

src/constants.h

@@ -88,8 +88,8 @@ typedef enum { CONTRACT_DATA_ENABLED = true, CONTRACT_DATA_DISABLED = false } co
 #define SHA3_KECCAK_BITS                   256
 #define PUBLIC_KEY_LEN                     32
 #define BASE_10                            10
-#define TX_SIGN_FLOW_SIZE                  9
-#define ESDT_TRANSFER_FLOW_SIZE            9
+#define TX_SIGN_FLOW_SIZE                  10
+#define ESDT_TRANSFER_FLOW_SIZE            10
 #define BASE_64_INVALID_CHAR               '?'
 #define SC_ARGS_SEPARATOR                  '@'
 #define MAX_ESDT_VALUE_HEX_COUNT           32

src/parse_tx.c

@@ -406,6 +406,19 @@ uint16_t verify_guardian(bool *valid) {
     return MSG_OK;
 }
 
+uint16_t verify_relayer(bool *valid) {
+    if (strncmp(tx_hash_context.current_field, RELAYER_FIELD, strlen(RELAYER_FIELD)) == 0) {
+        if (tx_hash_context.current_value_len >= sizeof(tx_context.relayer)) {
+            return ERR_INVALID_MESSAGE;
+        }
+        memmove(tx_context.relayer,
+                tx_hash_context.current_value,
+                tx_hash_context.current_value_len);
+        *valid = true;
+    }
+    return MSG_OK;
+}
+
 // verifies if the field and value are valid and stores them
 uint16_t process_field(void) {
     if (tx_hash_context.current_field_len == 0 || tx_hash_context.current_value_len == 0) {
@@ -452,6 +465,10 @@ uint16_t process_field(void) {
     if (err != MSG_OK) {
         return err;
     }
+    err = verify_relayer(&valid_field);
+    if (err != MSG_OK) {
+        return err;
+    }
 
     // verify the rest of the fields that are not displayed
     valid_field |= strncmp(tx_hash_context.current_field, NONCE_FIELD, strlen(NONCE_FIELD)) == 0;

src/parse_tx.h

@@ -17,6 +17,7 @@ typedef struct {
     char esdt_value[MAX_ESDT_VALUE_HEX_COUNT + PRETTY_SIZE];
     char network[8];
     char guardian[FULL_ADDRESS_LENGTH];
+    char relayer[FULL_ADDRESS_LENGTH];
 } tx_context_t;
 
 extern tx_context_t tx_context;

src/provide_ESDT_info.c

@@ -11,23 +11,28 @@ static bool verify_signature(const uint8_t *data_buffer,
     uint8_t hash[HASH_LEN];
     cx_sha256_t sha256;
     cx_ecfp_public_key_t tokenKey;
+    int err;
 
     cx_sha256_init(&sha256);
-    cx_hash_no_throw((cx_hash_t *) &sha256, CX_LAST, data_buffer, required_len, hash, 32);
+    err = cx_hash_no_throw((cx_hash_t *) &sha256, CX_LAST, data_buffer, required_len, hash, 32);
+    if (err != CX_OK) {
+        return false;
+    }
 
-    cx_ecfp_init_public_key_no_throw(CX_CURVE_256K1,
-                                     LEDGER_SIGNATURE_PUBLIC_KEY,
-                                     sizeof(LEDGER_SIGNATURE_PUBLIC_KEY),
-                                     &tokenKey);
+    err = cx_ecfp_init_public_key_no_throw(CX_CURVE_256K1,
+                                           LEDGER_SIGNATURE_PUBLIC_KEY,
+                                           sizeof(LEDGER_SIGNATURE_PUBLIC_KEY),
+                                           &tokenKey);
+    if (err != CX_OK) {
+        return false;
+    }
 
     int signature_size = data_length - required_len;
-    return cx_ecdsa_verify(&tokenKey,
-                           CX_LAST,
-                           CX_SHA256,
-                           hash,
-                           32,
-                           data_buffer + required_len,
-                           signature_size);
+    return cx_ecdsa_verify_no_throw(&tokenKey,
+                                    hash,
+                                    32,
+                                    data_buffer + required_len,
+                                    signature_size);
 }
 #endif
 

src/sign_msg.c

@@ -145,9 +145,10 @@ void handle_sign_msg(uint8_t p1,
        the message length is computed in the first bulk, while the entire message
        can come in multiple bulks
    */
+    int err;
+
     if (p1 == P1_FIRST) {
         char message_length_str[11];
-
         // first 4 bytes from data_buffer should be the message length (big endian
         // uint32)
         if (data_length < 4) {
@@ -158,25 +159,34 @@ void handle_sign_msg(uint8_t p1,
         data_buffer += 4;
         data_length -= 4;
         // initialize hash with the constant string to prepend
-        cx_keccak_init_no_throw(&sha3_context, SHA3_KECCAK_BITS);
-        cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                         0,
-                         (uint8_t *) PREPEND,
-                         sizeof(PREPEND) - 1,
-                         NULL,
-                         0);
+        err = cx_keccak_init_no_throw(&sha3_context, SHA3_KECCAK_BITS);
+        if (err != CX_OK) {
+            THROW(err);
+        }
+        err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                               0,
+                               (uint8_t *) PREPEND,
+                               sizeof(PREPEND) - 1,
+                               NULL,
+                               0);
+        if (err != CX_OK) {
+            THROW(err);
+        }
 
         // convert message length to string and store it in the variable
         // `message_length_str`
         uint32_t_to_char_array(msg_context.len, message_length_str);
 
         // add the message length to the hash
-        cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                         0,
-                         (uint8_t *) message_length_str,
-                         strlen(message_length_str),
-                         NULL,
-                         0);
+        err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                               0,
+                               (uint8_t *) message_length_str,
+                               strlen(message_length_str),
+                               NULL,
+                               0);
+        if (err != CX_OK) {
+            THROW(err);
+        }
     } else {
         if (p1 != P1_MORE) {
             THROW(ERR_INVALID_P1);
@@ -190,19 +200,26 @@ void handle_sign_msg(uint8_t p1,
     }
 
     // add the received message part to the hash and decrease the remaining length
-    cx_hash_no_throw((cx_hash_t *) &sha3_context, 0, data_buffer, data_length, NULL, 0);
+    err = cx_hash_no_throw((cx_hash_t *) &sha3_context, 0, data_buffer, data_length, NULL, 0);
+    if (err != CX_OK) {
+        THROW(err);
+    }
     msg_context.len -= data_length;
     if (msg_context.len != 0) {
         THROW(MSG_OK);
     }
 
     // finalize hash, compute it and store it in `msg_context.strhash` for display
-    cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                     CX_LAST,
-                     data_buffer,
-                     0,
-                     msg_context.hash,
-                     HASH_LEN);
+    err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                           CX_LAST,
+                           data_buffer,
+                           0,
+                           msg_context.hash,
+                           HASH_LEN);
+    if (err != CX_OK) {
+        THROW(err);
+    }
+
     convert_to_hex_str(msg_context.strhash,
                        sizeof(msg_context.strhash),
                        msg_context.hash,

src/sign_msg_auth_token.c

@@ -300,6 +300,8 @@ void handle_auth_token(uint8_t p1,
         the account and address indexes, alongside token length are computed in
         the first bulk, while the entire token can come in multiple bulks
     */
+    int err;
+
     if (p1 == P1_FIRST) {
         clean_token_fields();
         token_auth_context.token[0] = '\0';
@@ -336,33 +338,46 @@ void handle_auth_token(uint8_t p1,
         update_token_display_data(data_buffer, data_length);
 
         // initialize hash with the constant string to prepend
-        cx_keccak_init_no_throw(&sha3_context, SHA3_KECCAK_BITS);
-        cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                         0,
-                         (uint8_t *) PREPEND,
-                         sizeof(PREPEND) - 1,
-                         NULL,
-                         0);
+        err = cx_keccak_init_no_throw(&sha3_context, SHA3_KECCAK_BITS);
+        if (err != CX_OK) {
+            THROW(err);
+        }
+
+        err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                               0,
+                               (uint8_t *) PREPEND,
+                               sizeof(PREPEND) - 1,
+                               NULL,
+                               0);
+        if (err != CX_OK) {
+            THROW(err);
+        }
 
         // convert message length to string and store it in the variable `tmp`
         uint32_t full_message_len = token_auth_context.len + BECH32_ADDRESS_LEN;
         uint32_t_to_char_array(full_message_len, token_length_str);
 
         // add the message length to the hash
-        cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                         0,
-                         (uint8_t *) token_length_str,
-                         strlen(token_length_str),
-                         NULL,
-                         0);
+        err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                               0,
+                               (uint8_t *) token_length_str,
+                               strlen(token_length_str),
+                               NULL,
+                               0);
+        if (err != CX_OK) {
+            THROW(err);
+        }
 
         // add the message length to the hash
-        cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                         0,
-                         (uint8_t *) token_auth_context.address,
-                         strlen(token_auth_context.address),
-                         NULL,
-                         0);
+        err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                               0,
+                               (uint8_t *) token_auth_context.address,
+                               strlen(token_auth_context.address),
+                               NULL,
+                               0);
+        if (err != CX_OK) {
+            THROW(err);
+        }
     } else {
         if (p1 != P1_MORE) {
             THROW(ERR_INVALID_P1);
@@ -376,20 +391,26 @@ void handle_auth_token(uint8_t p1,
     }
 
     // add the received message part to the hash and decrease the remaining length
-    cx_hash_no_throw((cx_hash_t *) &sha3_context, 0, data_buffer, data_length, NULL, 0);
+    err = cx_hash_no_throw((cx_hash_t *) &sha3_context, 0, data_buffer, data_length, NULL, 0);
+    if (err != CX_OK) {
+        THROW(err);
+    }
 
     token_auth_context.len -= data_length;
     if (token_auth_context.len != 0) {
         THROW(MSG_OK);
     }
 
     // finalize hash and compute it
-    cx_hash_no_throw((cx_hash_t *) &sha3_context,
-                     CX_LAST,
-                     data_buffer,
-                     0,
-                     token_auth_context.hash,
-                     HASH_LEN);
+    err = cx_hash_no_throw((cx_hash_t *) &sha3_context,
+                           CX_LAST,
+                           data_buffer,
+                           0,
+                           token_auth_context.hash,
+                           HASH_LEN);
+    if (err != CX_OK) {
+        THROW(err);
+    }
 
     // sign the hash
     if (!sign_auth_token()) {