fix metadata print

Author: abenso

app/src/metadata_reader.c

@@ -15,16 +15,7 @@
  ********************************************************************************/
 
 #include "metadata_reader.h"
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
 #include "borsh.h"
-#include "parser_common.h"
-#include "parser_impl.h"
-#include "parser_txdef.h"
-#include "zxmacros.h"
 
 #if defined(TARGET_NANOS) || defined(TARGET_NANOX) || defined(TARGET_NANOS2) || defined(TARGET_STAX) || defined(TARGET_FLEX)
 #define STACK_SHIFT 20
@@ -78,21 +69,21 @@ parser_error_t read_fixed_point_display(parser_context_t *ctx, fixed_point_displ
 
     // read type
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&display->type));
-    printf("type fixed point display: %d\n", display->type);
+    print_u8("type fixed point display:", display->type);
 
     switch (display->type) {
         case FIXED_POINT_DISPLAY_DECIMALS:
             CHECK_ERROR(read_u8(ctx, (uint8_t *)&display->decimals));
-            printf("fixed point display decimals: %d\n", display->decimals);
+            print_u8("fixed point display decimals:", display->decimals);
             break;
         case FIXED_POINT_DISPLAY_FROM_SIBLING_FIELD:
             CHECK_ERROR(read_u64(ctx, (uint64_t *)&display->from_sibling_field.field_index));
             CHECK_ERROR(read_u64(ctx, (uint64_t *)&display->from_sibling_field.byte_offset));
-            printf("fixed point display from sibling field: %llu\n", display->from_sibling_field.field_index);
-            printf("fixed point display from sibling field: %llu\n", display->from_sibling_field.byte_offset);
+            print_u64("fixed point display from sibling field:", display->from_sibling_field.field_index);
+            print_u64("fixed point display from sibling field:", display->from_sibling_field.byte_offset);
             break;
         default:
-            printf("fixed point display unknown!!!!");
+            print_string("fixed point display unknown!!!!");
             return parser_no_data;
     }
 
@@ -105,21 +96,21 @@ parser_error_t read_integer_display(parser_context_t *ctx, integer_display_t *di
 
     // read type
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&display->type));
-    printf("type integer display: %d\n", display->type);
+    print_u8("type integer display:", display->type);
 
     switch (display->type) {
         case INTEGER_DISPLAY_HEX:
-            printf("integer display hex\n");
+            print_string("integer display hex");
             break;
         case INTEGER_DISPLAY_DECIMAL:
-            printf("integer display decimal\n");
+            print_string("integer display decimal");
             break;
         case INTEGER_DISPLAY_FIXED_POINT:
-            printf("integer display fixed point\n");
+            print_string("integer display fixed point");
             CHECK_ERROR(read_fixed_point_display(ctx, &display->fixed_point));
             break;
         default:
-            printf("integer display unknown!!!!");
+            print_string("integer display unknown!!!!");
             return parser_no_data;
     }
     return parser_ok;
@@ -130,7 +121,7 @@ parser_error_t read_hrp(parser_context_t *ctx, hrp_t *hrp) {
     CHECK_INPUT(ctx);
 
     CHECK_ERROR(read_u32(ctx, (uint32_t *)&hrp->prefix.len));
-    printf("hrp size: %d\n", hrp->prefix.len);
+    print_u16("hrp size:", hrp->prefix.len);
     if (hrp->prefix.len > 0) {
         hrp->prefix.ptr = ctx->buffer + ctx->offset;
         CTX_CHECK_AND_ADVANCE(ctx, hrp->prefix.len);
@@ -147,28 +138,28 @@ parser_error_t read_byte_display(parser_context_t *ctx, byte_display_t *display)
 
     // read type
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&display->type));
-    printf("type byte display: %d\n", display->type);
+    print_u8("type byte display:", display->type);
 
     switch (display->type) {
         case BYTE_DISPLAY_HEX:
-            printf("byte display hex\n");
+            print_string("byte display hex");
             break;
         case BYTE_DISPLAY_DECIMAL:
-            printf("byte display decimal\n");
+            print_string("byte display decimal");
             break;
         case BYTE_DISPLAY_BECH32:
-            printf("byte display bech32\n");
+            print_string("byte display bech32");
             CHECK_ERROR(read_hrp(ctx, &display->bech32.prefix));
             break;
         case BYTE_DISPLAY_BECH32M:
-            printf("byte display bech32m\n");
+            print_string("byte display bech32m");
             CHECK_ERROR(read_hrp(ctx, &display->bech32m.prefix));
             break;
         case BYTE_DISPLAY_BASE58:
-            printf("byte display base58\n");
+            print_string("byte display base58");
             break;
         default:
-            printf("byte display unknown!!!!");
+            print_string("byte display unknown!!!!");
             return parser_no_data;
     }
 
@@ -181,7 +172,7 @@ parser_error_t read_primitive_integer(parser_context_t *ctx, primitive_integer_t
 
     // read type
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&primitive->type));
-    printf("type primitive integer: %d\n", primitive->type);
+    print_u8("type primitive integer:", primitive->type);
 
     // read display
     CHECK_ERROR(read_integer_display(ctx, &primitive->display));
@@ -195,7 +186,7 @@ parser_error_t read_primitive_byte_array(parser_context_t *ctx, primitive_byte_a
 
     // read length
     CHECK_ERROR(read_u64(ctx, (uint64_t *)&primitive->len));
-    printf("length primitive byte array: %llu\n", primitive->len);
+    print_u64("length primitive byte array:", primitive->len);
 
     // read display
     CHECK_ERROR(read_byte_display(ctx, &primitive->display));
@@ -209,7 +200,7 @@ parser_error_t read_immediate(parser_context_t *ctx, primitive_t *primitive) {
 
     // read type
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&primitive->type));
-    printf("type immediate: %d\n", primitive->type);
+    print_u8("type immediate:", primitive->type);
 
     // read data
     switch (primitive->type) {
@@ -241,7 +232,7 @@ parser_error_t read_immediate(parser_context_t *ctx, primitive_t *primitive) {
             print_string("Primitive skip");
             break;
         default:
-            printf("link unknown!!!!");
+            print_string("link unknown!!!!");
             return parser_no_data;
     }
     return parser_ok;
@@ -253,20 +244,20 @@ parser_error_t read_link(parser_context_t *ctx, link_t *link) {
 
     // read tag
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&link->tag));
-    printf("link tag: %d\n", link->tag);
+    print_u8("link tag:", link->tag);
 
     // read data
     switch (link->tag) {
         case LINK_BY_INDEX:
             CHECK_ERROR(read_u64(ctx, (uint64_t *)&link->data.by_index));
-            printf("link by index: %llu\n", link->data.by_index);
+            print_u64("link by index:", link->data.by_index);
             break;
         case LINK_IMMEDIATE:
             CHECK_ERROR(read_immediate(ctx, &link->data.immediate));
             break;
         default:
             // TODO: change this
-            printf("link unknown!!!!");
+            print_string("link unknown!!!!");
             return parser_no_data;
     }
 
@@ -288,11 +279,11 @@ parser_error_t read_enum_variant(parser_context_t *ctx, enum_variant_t *variant)
 
     // read discriminant
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&variant->discriminant));
-    printf("discriminant: %d\n", variant->discriminant);
+    print_u8("discriminant:", variant->discriminant);
 
     // read has_value
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&variant->has_value));
-    printf("has_value: %d\n", variant->has_value);
+    print_u8("has_value:", variant->has_value);
     if (variant->has_value) {
         // read value
         CHECK_ERROR(read_link(ctx, &variant->value));
@@ -316,7 +307,7 @@ parser_error_t read_named_field(parser_context_t *ctx, named_field_t *field) {
 
     // read silent
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&field->silent));
-    printf("silent: %d\n", field->silent);
+    print_u8("silent:", field->silent);
 
     // read value
     CHECK_ERROR(read_link(ctx, &field->value));
@@ -341,7 +332,7 @@ parser_error_t read_unnamed_field(parser_context_t *ctx, unnamed_field_t *field)
 
     // read silent
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&field->silent));
-    printf("silent: %d\n", field->silent);
+    print_u8("silent:", field->silent);
 
     // read doc
     CHECK_ERROR(read_u32(ctx, (uint32_t *)&field->doc.len));
@@ -369,7 +360,7 @@ parser_error_t read_enum(parser_context_t *ctx, schema_enum_t *schema_enum) {
 
     // read variants_qty
     CHECK_ERROR(read_u32(ctx, &schema_enum->variants_qty));
-    printf("variants_qty: %d\n", schema_enum->variants_qty);
+    print_u32("variants_qty:", schema_enum->variants_qty);
     if (schema_enum->variants_qty > MAX_VARIANTS_QTY) {
         return parser_too_many_variants;
     }
@@ -381,7 +372,7 @@ parser_error_t read_enum(parser_context_t *ctx, schema_enum_t *schema_enum) {
 
     // read hide_tag
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_enum->hide_tag));
-    printf("hide_tag: %d\n", schema_enum->hide_tag);
+    print_u8("hide_tag:", schema_enum->hide_tag);
 
     return parser_ok;
 }
@@ -401,7 +392,7 @@ parser_error_t read_struct(parser_context_t *ctx, schema_struct_t *schema_struct
 
     // read has_show_as
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_struct->has_show_as));
-    printf("has_show_as: %d\n", schema_struct->has_show_as);
+    print_u8("has_show_as:", schema_struct->has_show_as);
     if (schema_struct->has_show_as) {
         CHECK_ERROR(read_u32(ctx, (uint32_t *)&schema_struct->show_as.len));
         if (schema_struct->show_as.len == 0) {
@@ -417,7 +408,7 @@ parser_error_t read_struct(parser_context_t *ctx, schema_struct_t *schema_struct
 
     // read has_structured_show_as
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_struct->has_structured_show_as));
-    printf("has_structured_show_as: %d\n", schema_struct->has_structured_show_as);
+    print_u8("has_structured_show_as:", schema_struct->has_structured_show_as);
     if (schema_struct->has_structured_show_as) {
         CHECK_ERROR(read_u32(ctx, (uint32_t *)&schema_struct->structured_show_as.len));
         if (schema_struct->structured_show_as.len == 0) {
@@ -433,14 +424,14 @@ parser_error_t read_struct(parser_context_t *ctx, schema_struct_t *schema_struct
 
     // read peekable
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_struct->peekable));
-    printf("peekable: %d\n", schema_struct->peekable);
+    print_u8("peekable:", schema_struct->peekable);
 
     // read fields
     CHECK_ERROR(read_u32(ctx, &schema_struct->fields_qty));
     if (schema_struct->fields_qty > MAX_FIELDS_QTY) {
         return parser_too_many_fields;
     }
-    printf("fields_qty: %d\n", schema_struct->fields_qty);
+    print_u32("fields_qty:", schema_struct->fields_qty);
     for (uint32_t i = 0; i < schema_struct->fields_qty; i++) {
         named_field_t field = {0};
         CHECK_ERROR(read_named_field(ctx, &field));
@@ -456,7 +447,7 @@ parser_error_t read_tuple(parser_context_t *ctx, schema_tuple_t *schema_tuple) {
 
     // read has_show_as
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_tuple->has_show_as));
-    printf("has_show_as: %d\n", schema_tuple->has_show_as);
+    print_u8("has_show_as:", schema_tuple->has_show_as);
     if (schema_tuple->has_show_as) {
         CHECK_ERROR(read_u32(ctx, (uint32_t *)&schema_tuple->show_as.len));
         if (schema_tuple->show_as.len == 0) {
@@ -472,7 +463,7 @@ parser_error_t read_tuple(parser_context_t *ctx, schema_tuple_t *schema_tuple) {
 
     // read has_structured_show_as
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_tuple->has_structured_show_as));
-    printf("has_structured_show_as: %d\n", schema_tuple->has_structured_show_as);
+    print_u8("has_structured_show_as:", schema_tuple->has_structured_show_as);
     if (schema_tuple->has_structured_show_as) {
         CHECK_ERROR(read_u32(ctx, (uint32_t *)&schema_tuple->structured_show_as.len));
         if (schema_tuple->structured_show_as.len == 0) {
@@ -488,14 +479,14 @@ parser_error_t read_tuple(parser_context_t *ctx, schema_tuple_t *schema_tuple) {
 
     // read peekable
     CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_tuple->peekable));
-    printf("peekable: %d\n", schema_tuple->peekable);
+    print_u8("peekable:", schema_tuple->peekable);
 
     // read fields
     CHECK_ERROR(read_u32(ctx, &schema_tuple->fields_qty));
     if (schema_tuple->fields_qty > MAX_FIELDS_QTY) {
         return parser_too_many_fields;
     }
-    printf("fields_qty: %d\n", schema_tuple->fields_qty);
+    print_u32("fields_qty:", schema_tuple->fields_qty);
     for (uint32_t i = 0; i < schema_tuple->fields_qty; i++) {
         unnamed_field_t field = {0};
         CHECK_ERROR(read_unnamed_field(ctx, &field));
@@ -511,7 +502,7 @@ parser_error_t read_array(parser_context_t *ctx, schema_array_t *schema_array) {
 
     // read length
     CHECK_ERROR(read_u64(ctx, (uint64_t *)&schema_array->len));
-    printf("array length: %llu\n", schema_array->len);
+    print_u64("array length:", schema_array->len);
 
     // read vec_type
     CHECK_ERROR(read_link(ctx, &schema_array->value));
@@ -524,7 +515,7 @@ parser_error_t metadata_read(parser_context_t *ctx, parser_tx_t *txObj) {
     CHECK_INPUT(txObj);
 
     CHECK_ERROR(read_u32(ctx, &txObj->schema.types.qty));
-    printf("types.qty: %d\n", txObj->schema.types.qty);
+    print_u32("types.qty:", txObj->schema.types.qty);
     if (txObj->schema.types.qty > MAX_SCHEMES_QTY) {
         return parser_too_many_schemes;
     }
@@ -578,7 +569,7 @@ parser_error_t metadata_read(parser_context_t *ctx, parser_tx_t *txObj) {
             case LINKING_SCHEME_SKIP:
                 print_string("READING SKIP");
                 CHECK_ERROR(read_u64(ctx, (uint64_t *)&txObj->schema.types.schemes[i].skip_type));
-                printf("skip_type: %llu\n", txObj->schema.types.schemes[i].skip_type);
+                print_u64("skip_type:", txObj->schema.types.schemes[i].skip_type);
                 print_string("READING SKIP DONE\n");
                 break;
             case LINKING_SCHEME_BYTE_VEC:
@@ -603,22 +594,22 @@ parser_error_t metadata_read(parser_context_t *ctx, parser_tx_t *txObj) {
                 print_string("READING MAP DONE\n");
                 break;
             default:
-                printf("UNKNOWN TYPE: %d\n", txObj->schema.types.schemes[i].type);
+                print_u8("UNKNOWN TYPE:", txObj->schema.types.schemes[i].type);
                 return parser_no_data;
         }
     }
 
     // read root_type_indices
     CHECK_ERROR(read_u32(ctx, &txObj->schema.root_type_indices.qty));
-    printf("root_type_indices.qty: %d\n", txObj->schema.root_type_indices.qty);
+    print_u32("root_type_indices.qty:", txObj->schema.root_type_indices.qty);
     for (uint32_t i = 0; i < txObj->schema.root_type_indices.qty; i++) {
         CHECK_ERROR(read_u64(ctx, &txObj->schema.root_type_indices.indices[i]));
-        printf("root_type_indices[%d]: %llu\n", i, txObj->schema.root_type_indices.indices[i]);
+        print_u64("root_type_indices[%d]:", txObj->schema.root_type_indices.indices[i]);
     }
 
     // read chain_data
     CHECK_ERROR(read_u64(ctx, &txObj->schema.chain_data.chain_id));
-    printf("chain_data.chain_id: %llu\n", txObj->schema.chain_data.chain_id);
+    print_u64("chain_data.chain_id:", txObj->schema.chain_data.chain_id);
     CHECK_ERROR(read_u32(ctx, (uint32_t *)&txObj->schema.chain_data.chain_name.len));
     if (txObj->schema.chain_data.chain_name.len > 0) {
         txObj->schema.chain_data.chain_name.ptr = ctx->buffer + ctx->offset;
@@ -633,5 +624,13 @@ parser_error_t metadata_read(parser_context_t *ctx, parser_tx_t *txObj) {
     CTX_CHECK_AND_ADVANCE(ctx, txObj->schema.extra_metadata_hash.len);
     print_buffer(&txObj->schema.extra_metadata_hash, "extra_metadata_hash");
 
+    // TODO: check that we have consumed all data
+    if (ctx->offset != ctx->bufferLen) {
+        print_string("Failed to parse metadata\n");
+        return parser_unexpected_error;
+    } else {
+        print_string("Successfully parsed metadata\n");
+    }
+
     return parser_ok;
 }

app/src/metadata_reader.h

@@ -20,8 +20,6 @@
 extern "C" {
 #endif
 
-#include <stdint.h>
-
 #include "parser_common.h"
 
 parser_error_t checkStack();