feat: format token amount due to token info

Author: Paulo Oliveira

app/src/parser/operation_parser.c

@@ -28,6 +28,44 @@ static tz_parser_result push_frame(tz_parser_state              *state,
                                    tz_operation_parser_step_kind step);
 static tz_parser_result pop_frame(tz_parser_state *state);
 
+typedef struct {
+    const char    name[32];
+    const char    symbol[12];
+    uint8_t       decimals;
+    const uint8_t contract_hash[20];
+} fa2_token_metadata_t;
+
+static const fa2_token_metadata_t FA2_TOKEN_REGISTRY[] = {
+    /* KT18amZmM5W7qDWVt2pH6uj7sCEd3kbzLrHT */
+    {"FA2 Token",
+     "FA2",
+     6,
+     {0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00}},
+};
+
+#define FA2_TOKEN_REGISTRY_SIZE \
+    (sizeof(FA2_TOKEN_REGISTRY) / sizeof(FA2_TOKEN_REGISTRY[0]))
+
+static const fa2_token_metadata_t *
+fa2_find_token(const uint8_t *destination_22bytes)
+{
+    if (destination_22bytes[0] != 1) {
+        return NULL;
+    }
+    for (size_t i = 0; i < FA2_TOKEN_REGISTRY_SIZE; i++) {
+        if (memcmp(destination_22bytes + 1,
+                   FA2_TOKEN_REGISTRY[i].contract_hash,
+                   20)
+            == 0) {
+            return &FA2_TOKEN_REGISTRY[i];
+        }
+    }
+    return NULL;
+}
+
 #ifdef TEZOS_DEBUG
 const char *const tz_operation_parser_step_name[] = {"OPTION",
                                                      "TUPLE",
@@ -605,6 +643,107 @@ tz_step_tag(tz_parser_state *state)
 #define FA2_TO_ADDR_OFS   (TZ_CAPTURE_BUFFER_SIZE / 2)
 #define FA2_ADDR_MAX_LEN  (TZ_CAPTURE_BUFFER_SIZE / 2 - 1)
 
+/**
+ * @brief Format an integer token amount string with token decimals and symbol.
+ *
+ * @param str       Decimal ASCII digits buffer (in/out, NUL-terminated).
+ * @param buf_size  Size of @p str (including the trailing NUL byte).
+ * @param decimals  Number of fractional digits for the token.
+ * @param symbol    Optional token symbol appended as " <symbol>" when it fits.
+ *
+ * Formatting is done in three phases:
+ * - left-pad with zeros when the integer has fewer than decimals+1 digits,
+ * - insert a decimal separator and trim trailing fractional zeros,
+ * - append the token symbol if enough space remains.
+ *
+ * The function never writes past @p buf_size. If the symbol would not fit, it
+ * is skipped and only the formatted amount is kept.
+ */
+static void
+tz_format_token_amount(char *str,
+                       size_t buf_size,
+                       uint8_t decimals,
+                       const char *symbol)
+{
+    size_t len;
+
+    if ((str == NULL) || (buf_size == 0)) {
+        return;
+    }
+
+    len = strlen(str);
+    if (len >= buf_size) {
+        str[buf_size - 1] = 0;
+        len               = buf_size - 1;
+    }
+
+    if (len == 0) {
+        if (buf_size < 2) {
+            str[0] = 0;
+            return;
+        }
+        str[0] = '0';
+        str[1] = 0;
+        len    = 1;
+    }
+
+    if (decimals > 0) {
+        size_t frac_digits = (size_t)decimals;
+
+        /* Ensure at least decimals+1 integer digits by left-padding with '0'. */
+        if (len <= frac_digits) {
+            int pad = (int)(frac_digits + 1U - len);
+            if ((len + (size_t)pad + 1U) > buf_size) {
+                return;
+            }
+            for (int j = (int)len; j >= 0; j--) {
+                str[j + pad] = str[j];
+            }
+            for (int j = 0; j < pad; j++) {
+                str[j] = '0';
+            }
+            len += (size_t)pad;
+        }
+
+        /* Detect whether the whole fractional part is zero. */
+        int no_decimals = 1;
+        for (size_t i = 0; i < frac_digits; i++) {
+            no_decimals &= (str[len - 1 - i] == '0');
+        }
+        if (no_decimals) {
+            str[len - frac_digits] = 0;
+            len -= frac_digits;
+        } else {
+            /* Insert '.', then trim trailing fractional zeros and a trailing '.'. */
+            if ((len + 1U) >= buf_size) {
+                return;
+            }
+            for (size_t i = 0; i < frac_digits; i++) {
+                str[len - i] = str[len - i - 1];
+            }
+            str[len - frac_digits] = '.';
+            len++;
+            str[len] = 0;
+            while ((len > 0) && (str[len - 1] == '0')) {
+                len--;
+                str[len] = 0;
+            }
+            if ((len > 0) && (str[len - 1] == '.')) {
+                len--;
+                str[len] = 0;
+            }
+        }
+    }
+
+    if ((symbol != NULL) && symbol[0]) {
+        size_t symbol_len = strlen(symbol);
+        if ((len + 1U + symbol_len + 1U) <= buf_size) {
+            strlcat(str, " ", buf_size);
+            strlcat(str, symbol, buf_size);
+        }
+    }
+}
+
 /**
  * @brief Switch FA2 parser to binary fallback for remaining bytes
  *
@@ -952,7 +1091,17 @@ tz_step_read_fa2_transfer(tz_parser_state *state)
         if (regs->oofs > 0) {
             tz_stop(IM_FULL);
         }
-        STRLCPY(state->field_info.field_name, "Token Amount");
+        if (op->frame->step_read_fa2.token_idx >= 0) {
+            const fa2_token_metadata_t *token
+                = &FA2_TOKEN_REGISTRY[op->frame->step_read_fa2.token_idx];
+            tz_format_token_amount((char *)state->buffers.num.decimal,
+                                   sizeof(state->buffers.num.decimal),
+                                   token->decimals,
+                                   token->symbol);
+            STRLCPY(state->field_info.field_name, token->name);
+        } else {
+            STRLCPY(state->field_info.field_name, "Token Amount");
+        }
         state->field_info.is_field_complex = false;
         state->field_info.field_index++;
         /* Pop the FA2 frame first, then push PRINT so PRINT pops to parent */
@@ -1544,12 +1693,19 @@ tz_step_field(tz_parser_state *state)
     }
     case TZ_OPERATION_FIELD_EXPR: {
         if (op->is_fa2_candidate && !field->skip) {
+            const fa2_token_metadata_t *token;
             op->frame->step = TZ_OPERATION_STEP_READ_FA2_TRANSFER;
             op->frame->step_read_fa2.sub_step = FA2_STEP_OUTER_SEQ_TAG;
             op->frame->step_read_fa2.addr_ofs = 0;
             op->frame->step_read_fa2.size_ofs = 0;
             op->frame->step_read_fa2.size_val = 0;
             op->frame->step_read_fa2.addr_len = 0;
+            op->frame->step_read_fa2.token_idx = -1;
+            token = fa2_find_token(op->destination);
+            if (token != NULL) {
+                op->frame->step_read_fa2.token_idx
+                    = (int8_t)(token - FA2_TOKEN_REGISTRY);
+            }
         } else {
             op->frame->step = TZ_OPERATION_STEP_READ_MICHELINE;
             op->frame->step_read_micheline.inited = 0;

app/src/parser/operation_state.h

@@ -233,6 +233,7 @@ typedef struct {
             uint32_t           size_val;   /// accumulator for 4-byte size
             uint16_t           addr_len;   /// remaining bytes for address
             tz_num_parser_regs num_state;  /// num parser state for amount
+            int8_t             token_idx;  /// matched token index, -1 if unknown
         } step_read_fa2;                   /// TZ_OPERATION_STEP_READ_FA2_TRANSFER
     };
 } tz_operation_parser_frame;