eth_json.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: LGPL-3.0-or-later
 * Copyright (c) 2026 Cryptnox SA
 */

 
#ifndef ETH_JSON_H
#define ETH_JSON_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef enum {
    ETH_JSON_RECEIPT_ERROR = 0, 
    ETH_JSON_RECEIPT_PENDING,   
    ETH_JSON_RECEIPT_SUCCESS,   
    ETH_JSON_RECEIPT_REVERTED,  
    ETH_JSON_RECEIPT_MISMATCH,  
} eth_json_receipt_t;

typedef struct {
    const char    *tx_hash;  
    const uint8_t *to;       
    const uint8_t *payee;    
    uint64_t       amount;   
} eth_receipt_expect_t;

bool eth_json_result_string(const char *resp, char *out, size_t out_size);

bool eth_json_error_message(const char *resp, char *out, size_t out_size);

eth_json_receipt_t eth_json_receipt_status(const char *resp);

eth_json_receipt_t eth_json_receipt_check(const char *resp,
                                          const eth_receipt_expect_t *want);

static inline bool eth_json_hex_u256(const char *hex, uint8_t out[32])
{
    if ((hex == NULL) || (out == NULL)) { return false; }
    if ((hex[0] != '0') || ((hex[1] != 'x') && (hex[1] != 'X'))) { return false; }
 
    const char *p = &hex[2];
    if (*p == '\0') { return false; }   /* "0x" on its own is not a quantity */
 
    /* Every digit is checked, leading zeros included: validating only the
     * significant ones would read "0x00zz" as zero rather than as garbage. */
    size_t len = 0U;
    while (p[len] != '\0') {
        const char c = p[len];
        const bool is_hex = ((c >= '0') && (c <= '9')) ||
                            ((c >= 'a') && (c <= 'f')) ||
                            ((c >= 'A') && (c <= 'F'));
        if (!is_hex) { return false; }
        len++;
    }
 
    /* Nodes pad a uint256 out to 64 characters; strip down to the significant
     * digits so the width test below is about the value, not the encoding.
     * One digit always survives, so "0x000" stays parseable as zero. */
    while ((*p == '0') && (p[1] != '\0')) { p++; len--; }
 
    if (len > 64U) {
        for (size_t i = 0U; i < 32U; i++) { out[i] = 0xFFU; }
        return true;
    }
 
    /* Right-aligned: the last digit is the low nibble of out[31]. */
    for (size_t i = 0U; i < 32U; i++) { out[i] = 0U; }
    for (size_t i = 0U; i < len; i++) {
        const char c = p[len - 1U - i];
        uint8_t n;
        if ((c >= '0') && (c <= '9'))      { n = (uint8_t)(c - '0'); }
        else if ((c >= 'a') && (c <= 'f')) { n = (uint8_t)((c - 'a') + 10); }
        else                               { n = (uint8_t)((c - 'A') + 10); }
        out[31U - (i / 2U)] |= (uint8_t)(((i % 2U) != 0U) ? (n << 4) : n);
    }
    return true;
}

static inline bool eth_json_hex_quantity(const char *hex, uint64_t *out)
{
    if (out == NULL) { return false; }
    uint8_t w[32];
    if (!eth_json_hex_u256(hex, w)) { return false; }
    uint64_t v = 0U;
    for (size_t i = 0U; i < 32U; i++) {
        if ((i < 24U) && (w[i] != 0U)) { *out = UINT64_MAX; return true; }
        if (i >= 24U) { v = (v << 8) | (uint64_t)w[i]; }
    }
    *out = v;
    return true;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ETH_JSON_H */