Align master with P1

.github/workflows/swap-ci-workflow.yml

@@ -13,5 +13,7 @@ jobs:
   job_functional_tests:
     uses: LedgerHQ/app-exchange/.github/workflows/reusable_swap_functional_tests.yml@develop
     with:
+      # Allow overriding the repo on forks
+      repo_for_tron: ${{ vars.REPO_FOR_TRON || null }}
       branch_for_tron: ${{ github.ref }}
       test_filter: '"TRX or trx or Tron or tron"'

VERSION

@@ -1 +1 @@
-0.7.3
+0.7.4

src/handlers/sign.c

@@ -54,12 +54,6 @@ static void fillVoteAmountSlot(void *destination, uint64_t value, uint8_t index)
     PRINTF("Amount: %d - %s\n", index, destination + (voteSlot(index, VOTE_AMOUNT)));
 }
 
-static void convertUint256BE(uint8_t *data, uint32_t length, uint256_t *target) {
-    uint8_t tmp[32] = {0};
-    memcpy(tmp + 32 - length, data, length);
-    readu256BE(tmp, target);
-}
-
 int handleSign(uint8_t p1, uint8_t p2, uint8_t *workBuffer, uint16_t dataLength) {
     uint256_t uint256;
     bool data_warning;
@@ -282,8 +276,9 @@ int handleSign(uint8_t p1, uint8_t p2, uint8_t *workBuffer, uint16_t dataLength)
                                     strlen((const char *) G_io_apdu_buffer + 100),
                                     (char *) G_io_apdu_buffer,
                                     100,
-                                    txContent.decimals[0]))
+                                    txContent.decimals[0])) {
                     return io_send_sw(E_INCORRECT_LENGTH);
+                }
             } else {
                 print_amount(
                     txContent.amount[0],

src/parse.c

@@ -39,6 +39,24 @@ tokenDefinition_t *getKnownToken(txContent_t *context) {
     return NULL;
 }
 
+/**
+ * Adjusts a numeric string by adding a decimal point at the specified position and trimming
+ * trailing zeros.
+ *
+ * @param[in] src
+ *   Pointer to the source numeric string.
+ * @param[in] srcLength
+ *   Length of the number as the number of actual characters (not the size of the buffer).
+ * @param[out] target
+ *   Pointer to the buffer where the adjusted string will be stored.
+ * @param[in] targetLength
+ *   Size of the target buffer.
+ * @param[in] decimals
+ *   Number of decimal places to shift.
+ *
+ * @return
+ *   True if successful, false otherwise (e.g., if the target buffer is too small).
+ */
 bool adjustDecimals(const char *src,
                     uint32_t srcLength,
                     char *target,

src/swap/handle_get_printable_amount.c

@@ -20,12 +20,12 @@
 
 #include "handle_swap_sign_transaction.h"
 #include "parse.h"
+#include "uint256.h"
 
 /* Set empty printable_amount on error, printable amount otherwise */
 void swap_handle_get_printable_amount(get_printable_amount_parameters_t* params) {
     uint8_t decimals;
     char ticker[MAX_SWAP_TOKEN_LENGTH] = {0};
-    uint64_t amount;
 
     PRINTF("Inside Tron swap_handle_get_printable_amount\n");
 
@@ -45,15 +45,20 @@ void swap_handle_get_printable_amount(get_printable_amount_parameters_t* params)
         }
     }
 
-    if (!swap_str_to_u64(params->amount, params->amount_length, &amount)) {
-        PRINTF("Amount is too big\n");
-        goto error;
-    }
+    uint256_t amount_number = {0};
+
+    // Raw amount string without a decimal point
+    char amount_raw_string[MAX_PRINTABLE_AMOUNT_SIZE] = {0};
+
+    convertUint256BE(params->amount, params->amount_length, &amount_number);
+
+    tostring256(&amount_number, 10, amount_raw_string, sizeof(amount_raw_string));
 
-    if (print_amount(amount,
-                     params->printable_amount,
-                     sizeof(params->printable_amount),
-                     decimals) == 0) {
+    if (!adjustDecimals(amount_raw_string,
+                        strnlen(amount_raw_string, sizeof(amount_raw_string)),
+                        params->printable_amount,
+                        sizeof(params->printable_amount),
+                        decimals)) {
         PRINTF("print_amount failed\n");
         goto error;
     }

src/swap/handle_swap_sign_transaction.c

@@ -20,12 +20,13 @@
 #include "swap.h"
 
 #include "parse.h"
+#include "uint256.h"
 
 typedef struct swap_validated_s {
     bool initialized;
     uint8_t decimals;
     char ticker[MAX_SWAP_TOKEN_LENGTH];
-    uint64_t amount;
+    uint256_t amount;
     char recipient[BASE58CHECK_ADDRESS_SIZE + 1];
 } swap_validated_t;
 
@@ -92,10 +93,7 @@ bool swap_copy_transaction_parameters(create_transaction_parameters_t* params) {
         return false;
     }
 
-    // Save amount
-    if (!swap_str_to_u64(params->amount, params->amount_length, &swap_validated.amount)) {
-        return false;
-    }
+    convertUint256BE(params->amount, params->amount_length, &swap_validated.amount);
 
     swap_validated.initialized = true;
 
@@ -111,17 +109,22 @@ bool swap_copy_transaction_parameters(create_transaction_parameters_t* params) {
 }
 
 // Check that the amount in parameter is the same as the previously saved amount
-static bool check_swap_amount(const char* amount) {
-    char validated_amount[MAX_PRINTABLE_AMOUNT_SIZE];
-    if (print_amount(G_swap_validated.amount,
-                     validated_amount,
-                     sizeof(validated_amount),
-                     G_swap_validated.decimals) == 0) {
+static bool check_swap_amount(const char* amount, const uint8_t decimals) {
+    char validated_amount[MAX_PRINTABLE_AMOUNT_SIZE] = {0};
+    char amount_raw_string[MAX_PRINTABLE_AMOUNT_SIZE] = {0};
+
+    tostring256(&G_swap_validated.amount, 10, amount_raw_string, sizeof(amount_raw_string));
+
+    if (!adjustDecimals(amount_raw_string,
+                        strnlen(amount_raw_string, sizeof(amount_raw_string)),
+                        validated_amount,
+                        sizeof(validated_amount),
+                        decimals)) {
         PRINTF("Conversion failed\n");
         return false;
     }
 
-    if (strcmp(amount, validated_amount) != 0) {
+    if (strncmp(amount, validated_amount, MAX_PRINTABLE_AMOUNT_SIZE) != 0) {
         PRINTF("Amount requested in this transaction = %s\n", amount);
         PRINTF("Amount validated in swap = %s\n", validated_amount);
         return false;
@@ -140,21 +143,21 @@ bool swap_check_validity(const char* amount,
         return false;
     }
 
-    if (!check_swap_amount(amount)) {
+    if (!check_swap_amount(amount, G_swap_validated.decimals)) {
         return false;
     }
 
-    if (strcmp(tokenName, G_swap_validated.ticker) != 0) {
+    if (strncmp(tokenName, G_swap_validated.ticker, MAX_SWAP_TOKEN_LENGTH) != 0) {
         PRINTF("Refused field '%s', expecting '%s'\n", tokenName, G_swap_validated.ticker);
         return false;
     }
 
-    if (strcmp(action, "To") != 0) {
+    if (strncmp(action, "To", 3) != 0) {
         PRINTF("Refused field '%s', expecting 'To'\n", action);
         return false;
     }
 
-    if (strcmp(G_swap_validated.recipient, toAddress) != 0) {
+    if (strncmp(G_swap_validated.recipient, toAddress, BASE58CHECK_ADDRESS_SIZE + 1) != 0) {
         PRINTF("Recipient requested in this transaction = %s\n", toAddress);
         PRINTF("Recipient validated in swap = %s\n", G_swap_validated.recipient);
         return false;

src/uint256.c

@@ -21,6 +21,8 @@
 #include <stdlib.h>
 #include "uint256.h"
 
+#include <string.h>
+
 static const char HEXDIGITS[] = "0123456789abcdef";
 
 static uint64_t readUint64BE(uint8_t *buffer) {
@@ -40,6 +42,12 @@ void readu256BE(uint8_t *buffer, uint256_t *target) {
     readu128BE(buffer + 16, &LOWER_P(target));
 }
 
+void convertUint256BE(const uint8_t *data, const uint32_t length, uint256_t *target) {
+    uint8_t tmp[32] = {0};
+    memcpy(tmp + 32 - length, data, length);
+    readu256BE(tmp, target);
+}
+
 bool zero128(uint128_t *number) {
     return ((LOWER_P(number) == 0) && (UPPER_P(number) == 0));
 }

src/uint256.h

@@ -35,6 +35,7 @@ typedef struct uint256_t {
 
 void readu128BE(uint8_t *buffer, uint128_t *target);
 void readu256BE(uint8_t *buffer, uint256_t *target);
+void convertUint256BE(const uint8_t *data, uint32_t length, uint256_t *target);
 bool zero128(uint128_t *number);
 bool zero256(uint256_t *number);
 void copy128(uint128_t *target, uint128_t *number);