ui_logic.c

#include "ui_logic.h"
#include "app_mem_utils.h"
#include "mem_utils.h"
#include "os_io.h"
#include "common_utils.h"  // uint256_to_decimal
#include "common_712.h"
#include "context_712.h"     // eip712_context_deinit
#include "path.h"            // path_get_root_type
#include "apdu_constants.h"  // APDU response codes
#include "typed_data.h"
#include "commands_712.h"
#include "common_ui.h"
#include "filtering.h"
#include "network.h"
#include "time_format.h"
#include "lists.h"
#include "ui_utils.h"
#include "utils.h"
#include "tx_ctx.h"  // g_parked_calldata
#include "read.h"    // read_u64_be

#define N_OF_M_LENGTH 10  // enough to hold "nn of mm"

#define AMOUNT_JOIN_FLAG_TOKEN  (1 << 0)
#define AMOUNT_JOIN_FLAG_VALUE  (1 << 1)
#define AMOUNT_JOIN_NAME_LENGTH 25

typedef struct amount_join {
    flist_node_t _list;
    // display name, NULL-terminated
    char name[AMOUNT_JOIN_NAME_LENGTH + 1];
    // indicates the steps the token join has gone through
    uint8_t flags;
    uint8_t token_idx;
    uint8_t value_length;
    uint8_t value[INT256_LENGTH];
} s_amount_join;

typedef enum {
    AMOUNT_JOIN_STATE_TOKEN,
    AMOUNT_JOIN_STATE_VALUE,
} e_amount_join_state;

#define UI_712_FIELD_SHOWN         (1 << 0)
#define UI_712_FIELD_NAME_PROVIDED (1 << 1)
#define UI_712_AMOUNT_JOIN         (1 << 2)
#define UI_712_DATETIME            (1 << 3)
#define UI_712_TRUSTED_NAME        (1 << 4)
#define UI_712_CALLDATA            (1 << 5)

typedef struct {
    s_amount_join *joins;
    uint8_t idx;
    e_amount_join_state state;
} s_amount_context;

typedef struct filter_crc {
    flist_node_t _list;
    uint32_t value;
} s_filter_crc;

typedef struct {
    bool end_reached;
    e_eip712_filtering_mode filtering_mode;
    uint8_t filters_to_process;
    bool message_info_received;
    uint8_t field_flags;
    uint8_t structs_to_review;
    s_amount_context amount;
    s_filter_crc *filters_crc;
    char *discarded_path;
    uint8_t tn_type_count;
    uint8_t tn_source_count;
    e_name_type tn_types[TN_TYPE_COUNT];
    e_name_source tn_sources[TN_SOURCE_COUNT];
    s_ui_712_pair *ui_pairs;
    s_eip712_calldata_info *calldata_info;
    uint8_t calldata_index;
} t_ui_context;

static t_ui_context *ui_ctx = NULL;

// to be used as a \ref f_list_node_del
static void delete_filter_crc(s_filter_crc *fcrc) {
    APP_MEM_FREE(fcrc);
}

// to be used as a \ref f_list_node_del
static void delete_ui_pair(s_ui_712_pair *pair) {
    APP_MEM_FREE(pair->key);
    APP_MEM_FREE(pair->value);
    APP_MEM_FREE(pair);
}

// to be used as a \ref f_list_node_del
static void delete_amount_join(s_amount_join *join) {
    APP_MEM_FREE(join);
}

/**
 * Called to fetch the next field if they have not all been processed yet
 *
 * Also handles the special "Review struct" screen of the verbose mode
 *
 * @return the next field state
 */
static bool ui_712_next_field(void) {
    bool ret = false;

    if (ui_ctx == NULL) {
        apdu_response_code = SWO_INCORRECT_DATA;
    } else {
        if (ui_ctx->structs_to_review > 0) {
            ret = ui_712_review_struct(path_get_nth_field_to_last(ui_ctx->structs_to_review));
            ui_ctx->structs_to_review -= 1;
        } else if (!ui_ctx->end_reached) {
            handle_eip712_return_code(true);
            // So that later when we append to them, we start from an empty string
            explicit_bzero(&strings, sizeof(strings));
            ret = true;
        }
    }
    return ret;
}

/**
 * Checks on the UI context to determine if the next EIP 712 field should be shown
 *
 * @return whether the next field should be shown
 */
static bool ui_712_field_shown(void) {
    bool ret = false;

    if (ui_ctx->filtering_mode == EIP712_FILTERING_BASIC) {
#ifdef SCREEN_SIZE_WALLET
        ret = true;
#else
        if (N_storage.verbose_eip712 || (path_get_root_type() == ROOT_DOMAIN)) {
            ret = true;
        }
#endif
    } else {  // EIP712_FILTERING_FULL
        if (ui_ctx->field_flags & UI_712_FIELD_SHOWN) {
            ret = true;
        }
    }
    return ret;
}

/**
 * Skip the field if needed and reset its UI flags
 */
void ui_712_finalize_field(void) {
    if (!ui_712_field_shown()) {
        ui_712_next_field();
    }
    ui_712_field_flags_reset();
}

/**
 * Set a new intent for the EIP-712 batch transaction
 *
 */
void ui_712_set_intent(void) {
    s_ui_712_pair *new_pair = NULL;
    const char *title = "Review transaction";
    size_t title_length = strlen(title);

    // Allocate memory for the new pair
    if (APP_MEM_CALLOC((void **) &new_pair, sizeof(*new_pair)) == false) {
        return;
    }
    // Add it to the chained list
    flist_push_back((flist_node_t **) &ui_ctx->ui_pairs, (flist_node_t *) new_pair);

    // Allocate and copy the title
    if (APP_MEM_CALLOC((void **) &new_pair->key, title_length + 1) == false) {
        return;
    }
    memcpy(new_pair->key, title, title_length);

    // Allocate and clear the intent buffer
    if (APP_MEM_CALLOC((void **) &new_pair->value, N_OF_M_LENGTH) == false) {
        return;
    }

    // Mark it as an intent
    new_pair->start_intent = true;
}

/**
 * Set a new title for the EIP-712 generic UX_STEP
 *
 * @param[in] str the new title
 * @param[in] length its length
 */
void ui_712_set_title(const char *str, size_t length) {
    s_ui_712_pair *new_pair = NULL;

    if (APP_MEM_CALLOC((void **) &new_pair, sizeof(*new_pair)) == false) {
        return;
    }
    flist_push_back((flist_node_t **) &ui_ctx->ui_pairs, (flist_node_t *) new_pair);
    if (APP_MEM_CALLOC((void **) &new_pair->key, length + 1) == false) {
        return;
    }
    memcpy(new_pair->key, str, length);
}

/**
 * Set a new value for the EIP-712 generic UX_STEP
 *
 * @note The parameters may be NULL if the value is already formatted into strings.tmp.tmp
 *
 * @param[in] str the new value
 * @param[in] length its length
 */
void ui_712_set_value(const char *str, size_t length) {
    s_ui_712_pair *tmp = ui_ctx->ui_pairs;

    if (tmp == NULL) {
        // No pairs created yet
        return;
    }
    while (((flist_node_t *) tmp)->next != NULL) {
        tmp = (s_ui_712_pair *) ((flist_node_t *) tmp)->next;
    }
    if (tmp->value != NULL) {
        PRINTF("Value already exist for tag %s: %s\n", tmp->key, tmp->value);
        return;
    }
    if ((str != NULL) && (length > 0)) {
        // buffer is directly provided with parameters
        if (APP_MEM_CALLOC((void **) &tmp->value, length + 1) == false) {
            return;
        }
        memcpy(tmp->value, str, length);
    } else {
        // Add the value from the global variable strings.tmp.tmp
        if ((tmp->value = APP_MEM_STRDUP(strings.tmp.tmp)) == NULL) {
            return;
        }
    }
    tmp->end_intent = validate_instruction_hash();
    if (tmp->end_intent) {
        PRINTF("[Intent] End\n");
    }
}

/**
 * Redraw the dynamic UI step that shows EIP712 information
 *
 * @return whether it was successful or not
 */
bool ui_712_redraw_generic_step(void) {
    if (appState != APP_STATE_SIGNING_EIP712) {  // Initialize if it is not already
        if ((ui_ctx->filtering_mode == EIP712_FILTERING_BASIC) && !N_storage.dataAllowed &&
            !N_storage.verbose_eip712) {
            // Both settings not enabled => Error
            ui_error_blind_signing();
            apdu_response_code = SWO_INCORRECT_DATA;
            eip712_context->go_home_on_failure = false;
            return false;
        }
        apdu_response_code = ui_712_start(ui_ctx->filtering_mode);
        if (apdu_response_code != SWO_SUCCESS) {
            return false;
        }
        handle_eip712_return_code(true);
    } else {
        if (ui_712_next_field() == false) {
            apdu_response_code = ui_sign_712(ui_ctx->filtering_mode);
            if (apdu_response_code != SWO_SUCCESS) {
                return false;
            }
        }
    }
    return true;
}

/**
 * Used to notify of a new struct to review
 *
 * @param[in] struct_ptr pointer to the structure to be shown
 * @return whether it was successful or not
 */
bool ui_712_review_struct(const s_struct_712 *struct_ptr) {
    const char *struct_name;
    const char *title = "Review struct";

    if (ui_ctx == NULL) {
        return false;
    }

    ui_712_set_title(title, strlen(title));
    if ((struct_name = struct_ptr->name) != NULL) {
        ui_712_set_value(struct_name, strlen(struct_name));
    }
    return ui_712_redraw_generic_step();
}

bool ui_712_review_network(const uint64_t *chain_id) {
    const char *title = "Network";
    const char *buf;

    if (*chain_id == chainConfig->chainId) {
        return true;
    }
    ui_712_set_title(title, strlen(title));
    if ((buf = get_network_name_from_chain_id(chain_id)) == NULL) {
        if (!u64_to_string(*chain_id, strings.tmp.tmp, NETWORK_STRING_MAX_SIZE)) {
            return false;
        }
        buf = strings.tmp.tmp;
    }
    ui_712_set_value(buf, strlen(buf));
    return ui_712_redraw_generic_step();
}

/**
 * Show the hash of the message on the generic UI step
 */
bool ui_712_message_hash(void) {
    const char *title = "Message hash";

    // to prevent showing
    // Message hash > Domain hash > Message hash
    // as the last three fields
    if (!N_storage.displayHash) {
        ui_712_set_title(title, strlen(title));
        array_bytes_string(strings.tmp.tmp,
                           sizeof(strings.tmp.tmp),
                           tmpCtx.messageSigningContext712.messageHash,
                           KECCAK256_HASH_BYTESIZE);
        ui_712_set_value(NULL, 0);
    }
    ui_ctx->end_reached = true;
    return ui_712_redraw_generic_step();
}

/**
 * Format a given data as a string
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] last if this is the last chunk
 */
static void ui_712_format_str(const uint8_t *data, uint8_t length, bool last) {
    size_t max_len = sizeof(strings.tmp.tmp) - 1;
    size_t cur_len = strlen(strings.tmp.tmp);
    size_t available;
    size_t to_copy;

    if (cur_len >= max_len) {
        // Ensure null-termination even if we're at capacity
        strings.tmp.tmp[max_len] = '\0';
        return;
    }

    available = max_len - cur_len;
    to_copy = MIN(available, length);

    memcpy(strings.tmp.tmp + cur_len, data, to_copy);
    strings.tmp.tmp[cur_len + to_copy] = '\0';

    // truncated - add ellipsis if this is the last chunk and we couldn't fit everything
    if (last && (to_copy < length)) {
        memcpy(strings.tmp.tmp + max_len - 3, "...", 3);
        strings.tmp.tmp[max_len] = '\0';
    }
}

/**
 * Format a given data as a string representation of an address
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] first if this is the first chunk
 * @return if the formatting was successful
 */
static bool ui_712_format_addr(const uint8_t *data, uint8_t length, bool first) {
    // no reason for an address to be received over multiple chunks
    if (!first) {
        return false;
    }
    if (length != ADDRESS_LENGTH) {
        apdu_response_code = SWO_INCORRECT_DATA;
        return false;
    }
    if (!getEthDisplayableAddress((uint8_t *) data,
                                  strings.tmp.tmp,
                                  sizeof(strings.tmp.tmp),
                                  chainConfig->chainId)) {
        apdu_response_code = SWO_PARAMETER_ERROR_NO_INFO;
        return false;
    }
    return true;
}

/**
 * Format given data as a string representation of a boolean
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] first if this is the first chunk
 * @return if the formatting was successful
 */
static bool ui_712_format_bool(const uint8_t *data, uint8_t length, bool first) {
    size_t max_len = sizeof(strings.tmp.tmp) - 1;
    const char *true_str = "true";
    const char *false_str = "false";
    const char *str;

    // no reason for a boolean to be received over multiple chunks
    if (!first) {
        return false;
    }
    if (length != 1) {
        apdu_response_code = SWO_INCORRECT_DATA;
        return false;
    }
    str = *data ? true_str : false_str;
    memcpy(strings.tmp.tmp, str, MIN(max_len, strlen(str)));
    return true;
}

/**
 * Format given data as a string representation of bytes
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] first if this is the first chunk
 * @param[in] last if this is the last chunk
 * @return if the formatting was successful
 */
static bool ui_712_format_bytes(const uint8_t *data, uint8_t length, bool first, bool last) {
    size_t max_len = sizeof(strings.tmp.tmp) - 1;
    size_t cur_len = strlen(strings.tmp.tmp);

    if (first) {
        memcpy(strings.tmp.tmp, "0x", MIN(max_len, 2));
        cur_len += 2;
    }
    if (format_hex(data,
                   MIN((max_len - cur_len) / 2, length),
                   strings.tmp.tmp + cur_len,
                   max_len + 1 - cur_len) < 0) {
        return false;
    }
    // truncated
    if (last && (((max_len - cur_len) / 2) < length)) {
        memcpy(strings.tmp.tmp + max_len - 3, "...", 3);
    }
    return true;
}

/**
 * Format given data as a string representation of an integer
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] first if this is the first chunk
 * @param[in] field_ptr pointer to the EIP-712 field
 * @return if the formatting was successful
 */
static bool ui_712_format_int(const uint8_t *data,
                              uint8_t length,
                              bool first,
                              const s_struct_712_field *field_ptr) {
    uint256_t value256;
    uint128_t value128;
    int32_t value32;
    int16_t value16;
    int8_t value8;
    uint8_t tmp[sizeof(int32_t)] = {0};

    // no reason for an integer to be received over multiple chunks
    if (!first) {
        return false;
    }
    if (length > field_ptr->type_size) {
        apdu_response_code = SWO_INCORRECT_DATA;
        return false;
    }

    switch (field_ptr->type_size * 8) {
        case 256:
            convertUint256BE(data, length, &value256);
            tostring256_signed(&value256, 10, strings.tmp.tmp, sizeof(strings.tmp.tmp));
            break;
        case 128:
            convertUint128BE(data, length, &value128);
            tostring128_signed(&value128, 10, strings.tmp.tmp, sizeof(strings.tmp.tmp));
            break;
        case 64:
            convertUint64BEto128(data, length, &value128);
            tostring128_signed(&value128, 10, strings.tmp.tmp, sizeof(strings.tmp.tmp));
            break;
        case 32:
            buf_shrink_expand(data, length, tmp, sizeof(int32_t));
            value32 = (int32_t) read_u32_be(tmp, 0);
            snprintf(strings.tmp.tmp, sizeof(strings.tmp.tmp), "%d", value32);
            break;
        case 16:
            buf_shrink_expand(data, length, tmp, sizeof(int16_t));
            value16 = (int16_t) read_u16_be(tmp, 0);
            snprintf(strings.tmp.tmp, sizeof(strings.tmp.tmp), "%d", value16);
            break;
        case 8:
            value8 = (int8_t) data[0];
            snprintf(strings.tmp.tmp, sizeof(strings.tmp.tmp), "%d", value8);
            break;
        default:
            PRINTF("Unhandled field typesize\n");
            apdu_response_code = SWO_INCORRECT_DATA;
            return false;
    }
    return true;
}

/**
 * Format given data as a string representation of an unsigned integer
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] first if this is the first chunk
 * @return if the formatting was successful
 */
static bool ui_712_format_uint(const uint8_t *data, uint8_t length, bool first) {
    uint256_t value256;

    // no reason for an integer to be received over multiple chunks
    if (!first) {
        return false;
    }
    convertUint256BE(data, length, &value256);
    tostring256(&value256, 10, strings.tmp.tmp, sizeof(strings.tmp.tmp));
    return true;
}

static s_amount_join *get_amount_join(uint8_t token_idx) {
    s_amount_join *tmp;
    s_amount_join *new;

    for (tmp = ui_ctx->amount.joins; tmp != NULL;
         tmp = (s_amount_join *) ((flist_node_t *) tmp)->next) {
        if (tmp->token_idx == token_idx) break;
    }
    if (tmp != NULL) return tmp;

    // does not exist, create it
    if (APP_MEM_CALLOC((void **) &new, sizeof(*new)) == false) {
        return NULL;
    }
    new->token_idx = token_idx;

    flist_push_back((flist_node_t **) &ui_ctx->amount.joins, (flist_node_t *) new);
    return new;
}

/**
 * Format given data as an amount with its ticker and value with correct decimals
 *
 * @return whether it was successful or not
 */
static bool ui_712_format_amount_join(void) {
    const tokenDefinition_t *token = NULL;
    s_amount_join *amount_join;

    if (tmpCtx.transactionContext.assetSet[ui_ctx->amount.idx]) {
        token = &tmpCtx.transactionContext.extraInfo[ui_ctx->amount.idx].token;
    }
    if ((amount_join = get_amount_join(ui_ctx->amount.idx)) == NULL) {
        return false;
    }
    if ((amount_join->value_length == INT256_LENGTH) &&
        ismaxint(amount_join->value, amount_join->value_length)) {
        strlcpy(strings.tmp.tmp, "Unlimited ", sizeof(strings.tmp.tmp));
        strlcat(strings.tmp.tmp,
                (token != NULL) ? token->ticker : g_unknown_ticker,
                sizeof(strings.tmp.tmp));
    } else {
        if (!amountToString(amount_join->value,
                            amount_join->value_length,
                            (token != NULL) ? token->decimals : 0,
                            (token != NULL) ? token->ticker : g_unknown_ticker,
                            strings.tmp.tmp,
                            sizeof(strings.tmp.tmp))) {
            return false;
        }
    }
    ui_ctx->field_flags |= UI_712_FIELD_SHOWN;
    ui_712_set_title(amount_join->name, strlen(amount_join->name));
    flist_remove((flist_node_t **) &ui_ctx->amount.joins,
                 (flist_node_t *) amount_join,
                 (f_list_node_del) delete_amount_join);
    return true;
}

/**
 * Simply mark the current amount-join's token address as received
 */
bool amount_join_set_token_received(void) {
    s_amount_join *amount_join = get_amount_join(ui_ctx->amount.idx);

    if (amount_join == NULL) return false;
    amount_join->flags |= AMOUNT_JOIN_FLAG_TOKEN;
    return true;
}

/**
 * Update the state of the amount-join
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @return whether it was successful or not
 */
static bool update_amount_join(const uint8_t *data, uint8_t length) {
    const tokenDefinition_t *token = NULL;
    s_amount_join *amount_join;

    if (tmpCtx.transactionContext.assetSet[ui_ctx->amount.idx]) {
        token = &tmpCtx.transactionContext.extraInfo[ui_ctx->amount.idx].token;
    } else {
        if (tmpCtx.transactionContext.currentAssetIndex == ui_ctx->amount.idx) {
            // So that the following amount-join find their tokens in the expected indices
            tmpCtx.transactionContext.currentAssetIndex =
                (tmpCtx.transactionContext.currentAssetIndex + 1) % MAX_ASSETS;
        }
    }
    switch (ui_ctx->amount.state) {
        case AMOUNT_JOIN_STATE_TOKEN:
            if (token != NULL) {
                if (memcmp(data, token->address, ADDRESS_LENGTH) != 0) {
                    return false;
                }
            }
            if (!amount_join_set_token_received()) {
                return false;
            }
            break;

        case AMOUNT_JOIN_STATE_VALUE:
            if ((amount_join = get_amount_join(ui_ctx->amount.idx)) == NULL) {
                return false;
            }
            if (length > sizeof(amount_join->value)) {
                apdu_response_code = SWO_INCORRECT_DATA;
                return false;
            }
            memcpy(amount_join->value, data, length);
            amount_join->value_length = length;
            amount_join->flags |= AMOUNT_JOIN_FLAG_VALUE;
            break;

        default:
            return false;
    }
    return true;
}

/**
 * Try to substitute given address by a matching contract name
 *
 * Fallback on showing the address if no match is found.
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @return whether it was successful or not
 */
static bool ui_712_format_trusted_name(const uint8_t *data, uint8_t length) {
    const s_trusted_name *trusted_name;

    if (length != ADDRESS_LENGTH) {
        return false;
    }
    if ((trusted_name = get_trusted_name(ui_ctx->tn_type_count,
                                         ui_ctx->tn_types,
                                         ui_ctx->tn_source_count,
                                         ui_ctx->tn_sources,
                                         &eip712_context->chain_id,
                                         data)) != NULL) {
        strlcpy(strings.tmp.tmp, trusted_name->name, sizeof(strings.tmp.tmp));
    }
    return true;
}

/**
 * Format given data as a human-readable date/time representation
 *
 * @param[in] data the data that needs formatting
 * @param[in] length its length
 * @param[in] field_ptr pointer to the new struct field
 * @return whether it was successful or not
 */
static bool ui_712_format_datetime(const uint8_t *data,
                                   uint8_t length,
                                   const s_struct_712_field *field_ptr) {
    time_t timestamp;

    if ((length >= field_ptr->type_size) && ismaxint((uint8_t *) data, length)) {
        snprintf(strings.tmp.tmp, sizeof(strings.tmp.tmp), "Unlimited");
        return true;
    }
    timestamp = u64_from_BE(data, length);
    return time_format_to_utc(&timestamp, strings.tmp.tmp, sizeof(strings.tmp.tmp));
}

static void ui_712_set_intent_field(const char *value) {
    const char key[] = "Transaction type";

    ui_712_set_title(key, strlen(key));
    ui_712_set_value(value, strlen(value));
}

static bool handle_fallback_empty_calldata(const s_eip712_calldata_info *calldata_info) {
    char *buf = strings.tmp.tmp;
    size_t buf_size = sizeof(strings.tmp.tmp);
    uint64_t chain_id;
    uint8_t decimals;
    const char *ticker;

    if (calldata_info->amount_state == CALLDATA_INFO_PARAM_SET) {
        ui_712_set_intent_field("Send");

        if (calldata_info->chain_id != 0) {
            chain_id = calldata_info->chain_id;
        } else {
            chain_id = eip712_context->chain_id;
        }

        ticker = get_displayable_ticker(&chain_id, chainConfig, true);
        decimals = WEI_TO_ETHER;
        if (!amountToString(calldata_info->amount,
                            sizeof(calldata_info->amount),
                            decimals,
                            ticker,
                            buf,
                            buf_size)) {
            return false;
        }
        ui_712_set_title("Amount", 6);
        ui_712_set_value(buf, strlen(buf));
    } else {
        ui_712_set_intent_field("Empty transaction");
    }

    e_name_type types[] = {TN_TYPE_ACCOUNT};
    e_name_source sources[] = {TN_SOURCE_ENS, TN_SOURCE_LAB, TN_SOURCE_MAB};
    const s_trusted_name *trusted_name;

    ui_712_set_title("To", 2);
    if ((trusted_name = get_trusted_name(ARRAYLEN(types),
                                         types,
                                         ARRAYLEN(sources),
                                         sources,
                                         &calldata_info->chain_id,
                                         calldata_info->callee)) != NULL) {
        ui_712_set_value(trusted_name->name, strlen(trusted_name->name));
    } else {
        if (!getEthDisplayableAddress(calldata_info->callee,
                                      buf,
                                      buf_size,
                                      calldata_info->chain_id)) {
            return false;
        }
        ui_712_set_value(buf, strlen(buf));
    }
    return true;
}

static bool update_calldata_value(const uint8_t *data,
                                  uint8_t length,
                                  const uint16_t *complete_length,
                                  bool last,
                                  s_eip712_calldata_info *calldata_info) {
    const uint8_t *selector = NULL;
    size_t calldata_size;

    if (calldata_info->value_state != CALLDATA_INFO_PARAM_UNSET) return false;
    if (complete_length != NULL) {
        calldata_size = *complete_length;
        if (calldata_size > 0) {
            if (calldata_info->selector_state == CALLDATA_INFO_PARAM_NONE) {
                if ((length < CALLDATA_SELECTOR_SIZE) || (calldata_size < CALLDATA_SELECTOR_SIZE)) {
                    return false;
                }
                selector = data;
                data += CALLDATA_SELECTOR_SIZE;
                length -= CALLDATA_SELECTOR_SIZE;
                calldata_size -= CALLDATA_SELECTOR_SIZE;
            } else if (calldata_info->selector_state == CALLDATA_INFO_PARAM_SET) {
                selector = calldata_info->selector;
            }
            if ((g_parked_calldata = calldata_init(calldata_size, selector)) == NULL) {
                return false;
            }
        }
    }
    if (g_parked_calldata != NULL) {
        if (!calldata_append(g_parked_calldata, data, length)) {
            return false;
        }
    } else {
        // won't receive a TX info & descriptors about a non-existent calldata
        calldata_info->processed = true;
    }
    if (last) calldata_info->value_state = CALLDATA_INFO_PARAM_SET;
    return true;
}

static bool update_calldata_callee(const uint8_t *data,
                                   uint8_t length,
                                   bool last,
                                   s_eip712_calldata_info *calldata_info) {
    if (calldata_info->callee_state != CALLDATA_INFO_PARAM_UNSET) return false;
    if (!last) return false;
    buf_shrink_expand(data, length, calldata_info->callee, sizeof(calldata_info->callee));
    calldata_info->callee_state = CALLDATA_INFO_PARAM_SET;
    return true;
}

static bool update_calldata_chain_id(const uint8_t *data,
                                     uint8_t length,
                                     bool last,
                                     s_eip712_calldata_info *calldata_info) {
    uint8_t chain_id_buf[sizeof(uint64_t)];

    if (calldata_info->chain_id_state != CALLDATA_INFO_PARAM_UNSET) return false;
    if (!last) return false;
    buf_shrink_expand(data, length, chain_id_buf, sizeof(chain_id_buf));
    calldata_info->chain_id = read_u64_be(chain_id_buf, 0);
    calldata_info->chain_id_state = CALLDATA_INFO_PARAM_SET;
    return true;
}

static bool update_calldata_selector(const uint8_t *data,
                                     uint8_t length,
                                     bool last,
                                     s_eip712_calldata_info *calldata_info) {
    if (calldata_info->selector_state != CALLDATA_INFO_PARAM_UNSET) return false;
    if (!last) return false;
    buf_shrink_expand(data, length, calldata_info->selector, sizeof(calldata_info->selector));
    calldata_info->selector_state = CALLDATA_INFO_PARAM_SET;
    if (calldata_info->value_state == CALLDATA_INFO_PARAM_SET) {
        calldata_set_selector(g_parked_calldata, calldata_info->selector);
    }
    return true;
}

static bool update_calldata_amount(const uint8_t *data,
                                   uint8_t length,
                                   bool last,
                                   s_eip712_calldata_info *calldata_info) {
    if (calldata_info->amount_state != CALLDATA_INFO_PARAM_UNSET) return false;
    if (!last) return false;
    buf_shrink_expand(data, length, calldata_info->amount, sizeof(calldata_info->amount));
    calldata_info->amount_state = CALLDATA_INFO_PARAM_SET;
    return true;
}

static bool update_calldata_spender(const uint8_t *data,
                                    uint8_t length,
                                    bool last,
                                    s_eip712_calldata_info *calldata_info) {
    if (calldata_info->spender_state != CALLDATA_INFO_PARAM_UNSET) return false;
    if (!last) return false;
    buf_shrink_expand(data, length, calldata_info->spender, sizeof(calldata_info->spender));
    calldata_info->spender_state = CALLDATA_INFO_PARAM_SET;
    return true;
}

static bool update_calldata(const uint8_t *data,
                            uint8_t length,
                            const uint16_t *complete_length,
                            bool last) {
    s_eip712_calldata_info *calldata_info = get_calldata_info(ui_ctx->calldata_index);

    if (calldata_info == NULL) return false;
    switch (calldata_info->state) {
        case EIP712_CALLDATA_VALUE:
            if (!update_calldata_value(data, length, complete_length, last, calldata_info))
                return false;
            break;
        case EIP712_CALLDATA_CALLEE:
            if (!update_calldata_callee(data, length, last, calldata_info)) return false;
            break;
        case EIP712_CALLDATA_CHAIN_ID:
            if (!update_calldata_chain_id(data, length, last, calldata_info)) return false;
            break;
        case EIP712_CALLDATA_SELECTOR:
            if (!update_calldata_selector(data, length, last, calldata_info)) return false;
            break;
        case EIP712_CALLDATA_AMOUNT:
            if (!update_calldata_amount(data, length, last, calldata_info)) return false;
            break;
        case EIP712_CALLDATA_SPENDER:
            if (!update_calldata_spender(data, length, last, calldata_info)) return false;
            break;
        default:
            return false;
    }
    if (calldata_info_all_received(calldata_info)) {
        if (g_parked_calldata == NULL) {
            if (!handle_fallback_empty_calldata(calldata_info)) return false;
        } else {
            if (!tx_ctx_init(g_parked_calldata,
                             calldata_info->spender,
                             calldata_info->callee,
                             calldata_info->amount,
                             &calldata_info->chain_id)) {
                calldata_delete(g_parked_calldata);
                g_parked_calldata = NULL;
                return false;
            }
            g_parked_calldata = NULL;
        }
    }
    return true;
}

/**
 * Formats and feeds the given input data to the display buffers
 *
 * @param[in] field_ptr pointer to the new struct field
 * @param[in] data pointer to the field's raw value
 * @param[in] length field's raw value byte-length
 * @param[in] complete_length pointer to complete length if first chunk, \ref NULL otherwise
 * @param[in] last if this is the last chunk
 */
bool ui_712_feed_to_display(const s_struct_712_field *field_ptr,
                            const uint8_t *data,
                            uint8_t length,
                            const uint16_t *complete_length,
                            bool last) {
    bool first = complete_length != NULL;

    if (ui_ctx == NULL) {
        apdu_response_code = SWO_INCORRECT_DATA;
        return false;
    }

    if (first && (strlen(strings.tmp.tmp) > 0)) {
        return false;
    }
    // Value
    if (ui_712_field_shown()) {
        switch (field_ptr->type) {
            case TYPE_SOL_STRING:
                ui_712_format_str(data, length, last);
                break;
            case TYPE_SOL_ADDRESS:
                if (ui_712_format_addr(data, length, first) == false) {
                    return false;
                }
                break;
            case TYPE_SOL_BOOL:
                if (ui_712_format_bool(data, length, first) == false) {
                    return false;
                }
                break;
            case TYPE_SOL_BYTES_FIX:
            case TYPE_SOL_BYTES_DYN:
                if (ui_712_format_bytes(data, length, first, last) == false) {
                    return false;
                }
                break;
            case TYPE_SOL_INT:
                if (ui_712_format_int(data, length, first, field_ptr) == false) {
                    return false;
                }
                break;
            case TYPE_SOL_UINT:
                if (ui_712_format_uint(data, length, first) == false) {
                    return false;
                }
                break;
            default:
                PRINTF("Unhandled type\n");
                return false;
        }
    }

    if (ui_ctx->field_flags & UI_712_AMOUNT_JOIN) {
        if (!update_amount_join(data, length)) {
            return false;
        }

        s_amount_join *amount_join = get_amount_join(ui_ctx->amount.idx);
        if (amount_join == NULL) {
            return false;
        }
        if (amount_join->flags == (AMOUNT_JOIN_FLAG_TOKEN | AMOUNT_JOIN_FLAG_VALUE)) {
            if (!ui_712_format_amount_join()) {
                return false;
            }
        }
    }

    if (ui_ctx->field_flags & UI_712_DATETIME) {
        if (!ui_712_format_datetime(data, length, field_ptr)) {
            return false;
        }
    }

    if (ui_ctx->field_flags & UI_712_TRUSTED_NAME) {
        if (!ui_712_format_trusted_name(data, length)) {
            return false;
        }
    }

    if (ui_ctx->field_flags & UI_712_CALLDATA) {
        if (!update_calldata(data, length, complete_length, last)) {
            return false;
        }
    }

    // Check if this field is supposed to be displayed
    if (last && ui_712_field_shown()) {
        // This is the last chunk, we can now set the value
        ui_712_set_value(NULL, 0);

        return ui_712_redraw_generic_step();
    }
    return true;
}

/**
 * Used to signal that we are done with reviewing the structs and we can now have
 * the option to approve or reject the signature
 */
void ui_712_end_sign(void) {
    if (ui_ctx == NULL) {
        apdu_response_code = SWO_COMMAND_NOT_ALLOWED;
        return;
    }

#ifdef SCREEN_SIZE_WALLET
    if (true) {
#else
    if (N_storage.verbose_eip712 || (ui_ctx->filtering_mode == EIP712_FILTERING_FULL)) {
#endif
        ui_ctx->end_reached = true;
        apdu_response_code = ui_sign_712(ui_ctx->filtering_mode);
    }
}

/**
 * Initializes the UI context structure in memory
 */
bool ui_712_init(void) {
    if (ui_ctx != NULL) {
        ui_712_deinit();
        return false;
    }

    if (APP_MEM_CALLOC((void **) &ui_ctx, sizeof(*ui_ctx)) == false) {
        apdu_response_code = SWO_INSUFFICIENT_MEMORY;
    } else {
        ui_712_set_filtering_mode(EIP712_FILTERING_BASIC);
        explicit_bzero(&strings, sizeof(strings));
    }
    return ui_ctx != NULL;
}

static void delete_calldata_info(s_eip712_calldata_info *node) {
    APP_MEM_FREE(node);
}

/**
 * Deinit function that simply unsets the struct pointer to NULL
 */
void ui_712_deinit(void) {
    if (ui_ctx != NULL) {
        if (ui_ctx->filters_crc != NULL) {
            flist_clear((flist_node_t **) &ui_ctx->filters_crc,
                        (f_list_node_del) &delete_filter_crc);
        }
        if (ui_ctx->ui_pairs != NULL) {
            flist_clear((flist_node_t **) &ui_ctx->ui_pairs, (f_list_node_del) &delete_ui_pair);
        }
        if (ui_ctx->amount.joins != NULL) {
            flist_clear((flist_node_t **) &ui_ctx->amount.joins,
                        (f_list_node_del) &delete_amount_join);
        }
        if (ui_ctx->calldata_info != NULL) {
            flist_clear((flist_node_t **) &ui_ctx->calldata_info,
                        (f_list_node_del) &delete_calldata_info);
            gcs_cleanup();
        }
        ui_712_clear_discarded_path();
        APP_MEM_FREE_AND_NULL((void **) &ui_ctx);
    }
}

/**
 * Approve button handling, calls the common handler function then
 * deinitializes the EIP712 context altogether.
 */
void ui_712_approve(void) {
    ui_712_approve_cb();
    eip712_context_deinit();
}

/**
 * Reject button handling, calls the common handler function then
 * deinitializes the EIP712 context altogether.

 */
void ui_712_reject(void) {
    ui_712_reject_cb();
    eip712_context_deinit();
}

/**
 * Set a structure field's UI flags
 *
 * @param[in] show if this field should be shown on the device
 * @param[in] name_provided if a substitution name has been provided
 * @param[in] token_join if this field is part of a token join
 * @param[in] datetime if this field should be shown and formatted as a date/time
 * @param[in] trusted_name if this field should be shown as a trusted contract name
 */
void ui_712_flag_field(bool show,
                       bool name_provided,
                       bool token_join,
                       bool datetime,
                       bool trusted_name,
                       bool calldata) {
    if (show) {
        ui_ctx->field_flags |= UI_712_FIELD_SHOWN;
    }
    if (name_provided) {
        ui_ctx->field_flags |= UI_712_FIELD_NAME_PROVIDED;
    }
    if (token_join) {
        ui_ctx->field_flags |= UI_712_AMOUNT_JOIN;
    }
    if (datetime) {
        ui_ctx->field_flags |= UI_712_DATETIME;
    }
    if (trusted_name) {
        ui_ctx->field_flags |= UI_712_TRUSTED_NAME;
    }
    if (calldata) {
        ui_ctx->field_flags |= UI_712_CALLDATA;
    }
}

/**
 * Set the UI filtering mode
 *
 * @param[in] the new filtering mode
 */
void ui_712_set_filtering_mode(e_eip712_filtering_mode mode) {
    ui_ctx->filtering_mode = mode;
}

/**
 * Get the UI filtering mode
 *
 * @return current filtering mode
 */
e_eip712_filtering_mode ui_712_get_filtering_mode(void) {
    return ui_ctx->filtering_mode;
}

/**
 * Set the number of filters this message should process
 *
 * @param[in] count number of filters
 */
void ui_712_set_filters_count(uint8_t count) {
    ui_ctx->filters_to_process = count;
    ui_ctx->message_info_received = true;
}

/**
 * Get the number of filters left to process
 *
 * @return number of filters
 */
uint8_t ui_712_remaining_filters(void) {
    return ui_ctx->filters_to_process - flist_size((flist_node_t **) &ui_ctx->filters_crc);
}

bool ui_712_message_info_received(void) {
    return ui_ctx->message_info_received;
}

/**
 * Reset all the UI struct field flags
 */
void ui_712_field_flags_reset(void) {
    ui_ctx->field_flags = 0;
}

/**
 * Add a struct to the UI review queue
 *
 * Makes it so the user will have to go through a "Review struct" screen
 */
void ui_712_queue_struct_to_review(void) {
#ifdef SCREEN_SIZE_WALLET
    if (true) {
#else
    if (N_storage.verbose_eip712) {
#endif
        ui_ctx->structs_to_review += 1;
    }
}

void ui_712_token_join_prepare_addr_check(uint8_t index) {
    ui_ctx->amount.idx = index;
    ui_ctx->amount.state = AMOUNT_JOIN_STATE_TOKEN;
}

bool ui_712_token_join_prepare_amount(uint8_t index, const char *name, uint8_t name_length) {
    s_amount_join *amount_join = get_amount_join(index);
    uint8_t cpy_len;

    if (amount_join == NULL) {
        return false;
    }
    cpy_len = MIN(sizeof(amount_join->name) - 1, name_length);
    ui_ctx->amount.idx = index;
    ui_ctx->amount.state = AMOUNT_JOIN_STATE_VALUE;
    memcpy(amount_join->name, name, cpy_len);
    amount_join->name[cpy_len] = '\0';
    return true;
}

/**
 * Set UI pair key to the raw JSON key
 *
 * @param[in] field_ptr pointer to the field
 * @return whether it was successful or not
 */
bool ui_712_show_raw_key(const s_struct_712_field *field_ptr) {
    const char *key;

    if ((key = field_ptr->key_name) == NULL) {
        return false;
    }

    if (ui_712_field_shown() && !(ui_ctx->field_flags & UI_712_FIELD_NAME_PROVIDED)) {
        ui_712_set_title(key, strlen(key));
    }
    return true;
}

/**
 * Push a new filter path
 *
 * @param[in] path_crc CRC of the filter path
 * @return whether it was successful or not
 */
bool ui_712_push_new_filter_path(uint32_t path_crc) {
    s_filter_crc *tmp;
    s_filter_crc *new_crc;
    uint8_t filter_count = 0;

    // check if already present
    for (tmp = ui_ctx->filters_crc; tmp != NULL;
         tmp = (s_filter_crc *) ((flist_node_t *) tmp)->next) {
        if (tmp->value == path_crc) {
            PRINTF("EIP-712 path CRC (%x) already found!\n", path_crc);
            return true;
        }
        filter_count += 1;
    }

    if (filter_count >= ui_ctx->filters_to_process) {
        apdu_response_code = SWO_INCORRECT_DATA;
        return false;
    }
    // allocate it
    if (APP_MEM_CALLOC((void **) &new_crc, sizeof(*new_crc)) == false) {
        apdu_response_code = SWO_INSUFFICIENT_MEMORY;
        return false;
    }
    new_crc->value = path_crc;

    PRINTF("Pushing new EIP-712 path CRC (%x)\n", path_crc);
    flist_push_back((flist_node_t **) &ui_ctx->filters_crc, (flist_node_t *) new_crc);
    return true;
}

/**
 * Set a discarded filter path
 *
 * @param[in] path the given filter path
 * @param[in] length the path length
 * @return whether it was successful or not
 */
bool ui_712_set_discarded_path(const char *path, uint8_t length) {
    if (ui_ctx->discarded_path != NULL) {
        return false;
    }
    if ((ui_ctx->discarded_path = APP_MEM_ALLOC(length + 1)) == NULL) {
        return false;
    }
    memcpy(ui_ctx->discarded_path, path, length);
    ui_ctx->discarded_path[length] = '\0';
    return true;
}

/**
 * Get the discarded filter path
 *
 * @return filter path
 */
const char *ui_712_get_discarded_path(void) {
    return ui_ctx->discarded_path;
}

void ui_712_clear_discarded_path(void) {
    APP_MEM_FREE_AND_NULL((void **) &ui_ctx->discarded_path);
}

void ui_712_set_trusted_name_requirements(uint8_t type_count,
                                          const e_name_type *types,
                                          uint8_t source_count,
                                          const e_name_source *sources) {
    ui_ctx->tn_type_count = type_count;
    memcpy(ui_ctx->tn_types, types, type_count);
    ui_ctx->tn_source_count = source_count;
    memcpy(ui_ctx->tn_sources, sources, source_count);
}

/**
 * Set the tag/value pairs for the review
 *
 */
void ui_712_push_pairs(void) {
    uint8_t nbPairs = 0;
    uint8_t pair = 0;
    s_ui_712_pair *tmp = NULL;
    uint8_t tx_idx = 0;

    // Initialize the pairs list
    nbPairs = flist_size((flist_node_t **) &ui_ctx->ui_pairs);
    if (N_storage.displayHash) {
        nbPairs += 2;
    }

    ui_pairs_init(nbPairs);
    // Initialize the tag/value pairs from the chain list
    tmp = ui_ctx->ui_pairs;
    while (tmp != NULL) {
        if (tmp->start_intent) {
            // Batch intermediate page
            tx_idx++;
            // Replace "nn of mm" placeholder, initialized in ui_712_set_intent()
            snprintf(tmp->value, N_OF_M_LENGTH, "%d of %d", tx_idx, txContext.batch_nb_tx);
            g_pairs[pair].centeredInfo = true;
        }
        g_pairs[pair].item = tmp->key;
        g_pairs[pair].value = tmp->value;
        LEDGER_ASSERT(pair < g_pairsList->nbPairs,
                      "EIP-712 pair overflow (%d / %d)",
                      pair,
                      g_pairsList->nbPairs);
        pair++;
        if ((tmp->end_intent) && (txContext.batch_nb_tx > 1)) {
            // End of batch transaction : start next info on full page
            g_pairs[pair].forcePageStart = true;
        }
        tmp = (s_ui_712_pair *) ((flist_node_t *) tmp)->next;
    }

    if (N_storage.displayHash) {
        LEDGER_ASSERT(pair < g_pairsList->nbPairs,
                      "EIP-712 pair overflow for Hash (%d / %d)",
                      pair,
                      g_pairsList->nbPairs);
        // Prepare the pairs list with the hashes
        eip712_format_hash(pair);
        g_pairs[pair].forcePageStart = true;
    }
}

void add_calldata_info(s_eip712_calldata_info *node) {
    flist_push_back((flist_node_t **) &ui_ctx->calldata_info, (flist_node_t *) node);
}

s_eip712_calldata_info *get_calldata_info(uint8_t index) {
    for (s_eip712_calldata_info *tmp = ui_ctx->calldata_info; tmp != NULL;
         tmp = (s_eip712_calldata_info *) ((flist_node_t *) tmp)->next) {
        if (index == tmp->index) {
            return tmp;
        }
    }
    return NULL;
}

s_eip712_calldata_info *get_current_calldata_info(void) {
    return get_calldata_info(ui_ctx->calldata_index);
}

bool all_calldata_info_processed(void) {
    for (const s_eip712_calldata_info *tmp = ui_ctx->calldata_info; tmp != NULL;
         tmp = (const s_eip712_calldata_info *) ((const flist_node_t *) tmp)->next) {
        if (!tmp->processed) return false;
    }
    return true;
}

void calldata_info_set_state(uint8_t index, e_eip712_calldata_state state) {
    s_eip712_calldata_info *calldata_info = get_calldata_info(index);

    ui_ctx->calldata_index = index;
    if (calldata_info != NULL) {
        calldata_info->state = state;
    }
}

bool calldata_info_all_received(const s_eip712_calldata_info *calldata_info) {
    if (calldata_info->value_state != CALLDATA_INFO_PARAM_SET) return false;
    if (calldata_info->callee_state != CALLDATA_INFO_PARAM_SET) return false;
    switch (calldata_info->chain_id_state) {
        case CALLDATA_INFO_PARAM_NONE:
        case CALLDATA_INFO_PARAM_SET:
            break;
        default:
            return false;
    }
    switch (calldata_info->selector_state) {
        case CALLDATA_INFO_PARAM_NONE:
        case CALLDATA_INFO_PARAM_SET:
            break;
        default:
            return false;
    }
    switch (calldata_info->amount_state) {
        case CALLDATA_INFO_PARAM_NONE:
        case CALLDATA_INFO_PARAM_SET:
            break;
        default:
            return false;
    }
    switch (calldata_info->spender_state) {
        case CALLDATA_INFO_PARAM_NONE:
        case CALLDATA_INFO_PARAM_SET:
            break;
        default:
            return false;
    }
    return true;
}