feat: Address stellar review feedback

Author: Keyur279

apps/stellar_app/stellar_context.h

@@ -31,9 +31,13 @@
 #define STELLAR_SECRET_KEY_LENGTH 57
 #define STELLAR_SIGNATURE_SIZE 64
 
+// Stellar XDR constants
+#define STELLAR_ENVELOPE_TYPE_TX 2
+#define STELLAR_KEY_TYPE_ED25519 0
+#define STELLAR_ASSET_TYPE_NATIVE 0
+
 // Network passphrases
-// See
-// https://developers.stellar.org/docs/learn/fundamentals/networks
+// See https://developers.stellar.org/docs/learn/fundamentals/networks
 #define TESTNET_PASSPHRASE "Test SDF Network ; September 2015"
 #define MAINNET_PASSPHRASE "Public Global Stellar Network ; September 2015"
 
@@ -46,28 +50,35 @@ typedef struct {
 } stellar_config_t;
 
 // Stellar Memo types
-// See
-// https://developers.stellar.org/docs/learn/encyclopedia/transactions-specialized/memos
+// See https://developers.stellar.org/docs/learn/encyclopedia/transactions-specialized/memos
 typedef enum {
-  MEMO_NONE = 0,
-  MEMO_TEXT = 1,
-  MEMO_ID = 2,
-  MEMO_HASH = 3,
-  MEMO_RETURN = 4
+  STELLAR_MEMO_NONE = 0,
+  STELLAR_MEMO_TEXT = 1,
+  STELLAR_MEMO_ID = 2,
+  STELLAR_MEMO_HASH = 3,
+  STELLAR_MEMO_RETURN = 4
 } stellar_memo_type_t;
 
+// Stellar operation types  
+// See https://developers.stellar.org/docs/learn/fundamentals/transactions/list-of-operations
+typedef enum {
+  STELLAR_OPERATION_CREATE_ACCOUNT = 0,
+  STELLAR_OPERATION_PAYMENT = 1
+} stellar_operation_type_t;
+
 // Stellar transaction structures
+// See https://developers.stellar.org/docs/learn/encyclopedia/data-format/xdr
 typedef struct {
   uint8_t source_account[32];
   uint64_t sequence_number;
   uint32_t fee;
   uint32_t operation_count;
-  uint32_t operation_type;    // CREATE_ACCOUNT = 0, PAYMENT = 1
+  stellar_operation_type_t operation_type;
   stellar_memo_type_t memo_type;
   union {
-    char text[29];       // MEMO_TEXT (max 28 bytes + 1 byte delimiter)
-    uint64_t id;         // MEMO_ID
-    uint8_t hash[32];    // MEMO_HASH or MEMO_RETURN(32 bytes)
+    char text[29];       // STELLAR_MEMO_TEXT (max 28 bytes + 1 byte delimiter)
+    uint64_t id;         // STELLAR_MEMO_ID
+    uint8_t hash[32];    // STELLAR_MEMO_HASH or STELLAR_MEMO_RETURN(32 bytes)
   } memo;
 } stellar_transaction_t;
 
@@ -88,20 +99,5 @@ typedef enum {
 /*****************************************************************************
  * GLOBAL FUNCTION PROTOTYPES
  *****************************************************************************/
-/**
- * @brief Generates a Stellar address from a public key
- * @details Follows the Stellar address generation algorithm:
- * 1. Creates a payload with account ID type (0x30) and the public key
- * 2. Calculates CRC16 checksum
- * 3. Encodes the result using base32
- * See
- * https://developers.stellar.org/docs/fundamentals-and-concepts/stellar-data-structures/accounts
- *
- * @param public_key The 32-byte ED25519 public key
- * @param address Buffer to store the resulting address (must be at least
- * STELLAR_ADDRESS_LENGTH bytes)
- * @return true if the address was generated successfully, false otherwise
- */
-bool stellar_generate_address(const uint8_t *public_key, char *address);
 
 #endif /* STELLAR_CONTEXT_H */

apps/stellar_app/stellar_helpers.c

@@ -62,6 +62,9 @@
 
 #include "stellar_helpers.h"
 
+#include "base32.h"
+#include "stellar_context.h"
+
 /*****************************************************************************
  * EXTERN VARIABLES
  *****************************************************************************/
@@ -78,6 +81,14 @@
  * STATIC FUNCTION PROTOTYPES
  *****************************************************************************/
 
+/**
+ * @brief Calculate CRC16 checksum for Stellar address encoding
+ * @param data Input data buffer
+ * @param len Length of input data
+ * @return CRC16 checksum
+ */
+static uint16_t crc16(const uint8_t *data, size_t len);
+
 /*****************************************************************************
  * STATIC VARIABLES
  *****************************************************************************/
@@ -90,6 +101,20 @@
  * STATIC FUNCTIONS
  *****************************************************************************/
 
+static uint16_t crc16(const uint8_t *data, size_t len) {
+  uint16_t crc = 0x0000;
+  for (size_t i = 0; i < len; i++) {
+    crc ^= data[i] << 8;
+    for (int j = 0; j < 8; j++) {
+      if (crc & 0x8000)
+        crc = (crc << 1) ^ 0x1021;
+      else
+        crc <<= 1;
+    }
+  }
+  return crc;
+}
+
 /*****************************************************************************
  * GLOBAL FUNCTIONS
  *****************************************************************************/
@@ -108,3 +133,25 @@ bool stellar_derivation_path_guard(const uint32_t *path, uint8_t levels) {
 
   return status;
 }
+
+bool stellar_generate_address(const uint8_t *public_key, char *address) {
+  if (!public_key || !address) {
+    return false;
+  }
+
+  // Stellar address encoding (StrKey format)
+  // See https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md
+  uint8_t payload[35];
+  payload[0] = 0x30;    // Account ID version byte (6 << 3 | 0 = STRKEY_PUBKEY OR STRKEY_ALG_ED25519)
+  memcpy(payload + 1, public_key, STELLAR_PUBKEY_RAW_SIZE);
+
+  // CRC16-XModem checksum calculation
+  // See https://stellar.stackexchange.com/questions/255/which-cryptographic-algorithm-is-used-to-generate-the-secret-and-public-keys
+  uint16_t checksum = crc16(payload, 33);
+  payload[33] = checksum & 0xFF;
+  payload[34] = checksum >> 8;
+
+  // RFC4648 base32 encoding without padding
+  base32_encode(payload, 35, address, STELLAR_ADDRESS_LENGTH, BASE32_ALPHABET_RFC4648);
+  return true;
+}

apps/stellar_app/stellar_helpers.h

@@ -60,4 +60,19 @@
  */
 bool stellar_derivation_path_guard(const uint32_t *path, uint8_t levels);
 
+/**
+ * @brief Generates a Stellar address from a public key
+ * @details Follows the Stellar address generation algorithm:
+ * 1. Creates a payload with account ID type (0x30) and the public key
+ * 2. Calculates CRC16 checksum  
+ * 3. Encodes the result using base32
+ * See https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md
+ *
+ * @param public_key The 32-byte ED25519 public key
+ * @param address Buffer to store the resulting address (must be at least
+ * STELLAR_ADDRESS_LENGTH bytes)
+ * @return true if the address was generated successfully, false otherwise
+ */
+bool stellar_generate_address(const uint8_t *public_key, char *address);
+
 #endif    // STELLAR_HELPERS_H

apps/stellar_app/stellar_pub_key.c

@@ -219,6 +219,10 @@ static bool get_user_consent(const pb_size_t which_request,
  *****************************************************************************/
 static bool sign_address = false;
 
+/*****************************************************************************
+ * STATIC FUNCTIONS
+ *****************************************************************************/
+
 static bool check_which_request(const stellar_query_t *query,
                                 pb_size_t which_request) {
   if (which_request != query->get_public_keys.which_request) {
@@ -299,24 +303,13 @@ static bool get_public_key(const uint8_t *seed,
                            uint8_t *public_key) {
   HDNode node = {0};
 
-  // Initialize the HDNode with the seed
-  if (hdnode_from_seed(seed, 64, "ed25519", &node) != 1) {
+  // Use derive_hdnode_from_path instead of manual derivation
+  if (!derive_hdnode_from_path(path, path_length, ED25519_NAME, seed, &node)) {
     stellar_send_error(ERROR_COMMON_ERROR_UNKNOWN_ERROR_TAG, 1);
     memzero(&node, sizeof(HDNode));
     return false;
   }
 
-  // Derive HDNode from path
-  for (uint32_t i = 0; i < path_length; i++) {
-    if (hdnode_private_ckd(&node, path[i]) != 1) {
-      stellar_send_error(ERROR_COMMON_ERROR_UNKNOWN_ERROR_TAG, 1);
-      memzero(&node, sizeof(HDNode));
-      return false;
-    }
-  }
-
-  hdnode_fill_public_key(&node);
-
   if (NULL != public_key) {
     // skip first byte, use raw 32 bytes
     memcpy(public_key, node.public_key + 1, STELLAR_PUBKEY_RAW_SIZE);
@@ -342,20 +335,6 @@ static bool fill_public_keys(
   return true;
 }
 
-static uint16_t crc16(const uint8_t *data, size_t len) {
-  uint16_t crc = 0x0000;
-  for (size_t i = 0; i < len; i++) {
-    crc ^= data[i] << 8;
-    for (int j = 0; j < 8; j++) {
-      if (crc & 0x8000)
-        crc = (crc << 1) ^ 0x1021;
-      else
-        crc <<= 1;
-    }
-  }
-  return crc;
-}
-
 static bool send_public_keys(
     stellar_query_t *query,
     const uint8_t pubkey_list[][STELLAR_PUBKEY_RAW_SIZE],
@@ -399,38 +378,10 @@ static bool send_public_keys(
  * GLOBAL VARIABLES
  *****************************************************************************/
 
-/*****************************************************************************
- * STATIC FUNCTIONS
- *****************************************************************************/
-
 /*****************************************************************************
  * GLOBAL FUNCTIONS
  *****************************************************************************/
 
-bool stellar_generate_address(const uint8_t *public_key, char *address) {
-  if (!public_key || !address) {
-    return false;
-  }
-
-  // Stellar address encoding (StrKey format)
-  // See
-  // https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md
-  uint8_t payload[35];
-  payload[0] = 6 << 3;    // Account ID version byte (0x30)
-  memcpy(payload + 1, public_key, 32);
-
-  // CRC16-XModem checksum calculation
-  // See
-  // https://stellar.stackexchange.com/questions/255/which-cryptographic-algorithm-is-used-to-generate-the-secret-and-public-keys
-  uint16_t checksum = crc16(payload, 33);
-  payload[33] = checksum & 0xFF;
-  payload[34] = checksum >> 8;
-
-  // RFC4648 base32 encoding without padding
-  base32_encode(payload, 35, address, 57, BASE32_ALPHABET_RFC4648);
-  return true;
-}
-
 void stellar_get_pub_keys(stellar_query_t *query) {
   char wallet_name[NAME_SIZE] = "";
   uint8_t seed[64] = {0};
@@ -489,6 +440,9 @@ void stellar_get_pub_keys(stellar_query_t *query) {
     if (!stellar_generate_address(pubkey_list[0], address)) {
       return;
     }
+    if (sign_address) {
+      exchange_sign_address(address, sizeof(address));
+    }
     if (!core_scroll_page(ui_text_receive_on, address, stellar_send_error)) {
       return;
     }
@@ -502,4 +456,4 @@ void stellar_get_pub_keys(stellar_query_t *query) {
   }
 
   delay_scr_init(ui_text_check_cysync_app, DELAY_TIME);
-}
+}