sia_parser.c

#include "sia_parser.h"

uint64_t read_le64(const uint8_t* data) {
    uint64_t result = 0;
    for (int i = 0; i < 8; i++) {
        result |= ((uint64_t)data[i]) << (i * 8);
    }
    return result;
}

void write_le64(uint8_t* buf, uint64_t value) {
    for (int i = 0; i < 8; i++) {
        buf[i] = (value >> (i * 8)) & 0xFF;
    }
}

void print_full_address(const uint8_t address_hash[32]) {
    // Calculate checksum
    uint8_t checksum[32];
    blake2b(address_hash, 32, checksum, 32);
    
    // Print full address: 32-byte hash + 6-byte checksum
    for (int i = 0; i < 32; i++) {
        printf("%02x", address_hash[i]);
    }
    for (int i = 0; i < 6; i++) {
        printf("%02x", checksum[i]);
    }
}

double convert_lohi_to_sc(uint64_t lo, uint64_t hi) {
    // Converting SC to hastings and is approximate for display purposes
    if (hi == 0) {
        return (double)lo / 1e24;
    } else {
        // For values with hi != 0, this is a rough approximation
        double hi_part = (double)hi * (double)(1ULL << 32) * (double)(1ULL << 32);
        return (hi_part + (double)lo) / 1e24;
    }
}

int parse_transaction_blob(const uint8_t* blob, size_t len, ParsedTxn* txn) {
    size_t offset = 0;
    
    // Parse input count
    if (len < offset + 8) return -1;
    txn->input_count = read_le64(blob + offset);
    offset += 8;
    
    printf("Parsing transaction with %llu inputs\n", txn->input_count);
    
    if (txn->input_count > MAX_INPUTS) {
        printf("Error: Too many inputs (%llu > %d)\n", txn->input_count, MAX_INPUTS);
        return -1;
    }
    
    // Parse parent IDs
    for (int i = 0; i < txn->input_count; i++) {
        if (len < offset + 32) return -1;
        memcpy(txn->parent_ids[i], blob + offset, 32);
        offset += 32;
        
        printf("Input %d parent ID: ", i);
        for (int j = 0; j < 32; j++) {
            printf("%02x", txn->parent_ids[i][j]);
        }
        printf("\n");
    }
    
    // Parse output count
    if (len < offset + 8) return -1;
    txn->output_count = read_le64(blob + offset);
    offset += 8;
    
    printf("Transaction has %llu outputs\n", txn->output_count);
    
    if (txn->output_count > MAX_OUTPUTS) {
        printf("Error: Too many outputs (%llu > %d)\n", txn->output_count, MAX_OUTPUTS);
        return -1;
    }
    
    // Parse outputs
    for (int i = 0; i < txn->output_count; i++) {
        if (len < offset + 48) return -1; // 32 + 8 + 8
        
        memcpy(txn->outputs[i].address_hash, blob + offset, 32);
        offset += 32;
        
        txn->outputs[i].value_lo = read_le64(blob + offset);
        offset += 8;
        
        txn->outputs[i].value_hi = read_le64(blob + offset);
        offset += 8;
        
        printf("Output %d:\n", i);
        printf("  To address: ");
        print_full_address(txn->outputs[i].address_hash);
        printf("\n");
        printf("  Amount: %.6f SC\n", convert_lohi_to_sc(txn->outputs[i].value_lo, txn->outputs[i].value_hi));
    }
    
    // Parse fee
    if (len < offset + 16) return -1;
    txn->fee_lo = read_le64(blob + offset);
    offset += 8;
    txn->fee_hi = read_le64(blob + offset);
    offset += 8;
    
    printf("Miner fee: %.6f SC\n", convert_lohi_to_sc(txn->fee_lo, txn->fee_hi));
    
    return 0;
}