Chain-State UTXOS Decoding: TXID, Block Height, and Balance Improper

I’m trying to make a rust tool set to read UTXOS directly from the chain state. I mostly follow Bitcoin sources in letters (at least I think so).

I have decode_varint

pub fn decode_varint(data: &(u8)) -> Option<(u32, usize)> {
    let mut n: u32 = 0;
    let mut shift = 0;

    for (i, &byte) in data.iter().enumerate().take(5) {
        let part = (byte & 0x7F) as u32;
        n |= part << shift;

        if byte & 0x80 == 0 {
            return Some((n, i + 1));
        }

        // Bitcoin adds this quirk:
        n = n.wrapping_add(1 << shift);
        shift += 7;
    }

    None
}

I have decompress_amount

pub fn decompress_amount(x: u64) -> u64 {
    if x == 0 {
        return 0;
    }
    let mut x = x - 1;
    let e = x % 10;
    x /= 10;
    let mut n;
    if e < 9 {
        let d = (x % 9) + 1;
        x /= 9;
        n = x * 10 + d;
    } else {
        n = x + 1;
    }
    for _ in 0..e {
        n *= 10;
    }
    n
}

I’m sure I get only UTXO entries

pub fn decode_utxo_key(mut key: &(u8)) -> Option<(Vec, u32)> {
    if key.is_empty() || key(0) != b'C' {
        return None;
    }
    key = &key(1..);
    let txid = key.get(..32)?.to_vec();
    key = &key(32..);
    let (vout, _) = decode_varint(key)?;
    Some((txid, vout as u32))
}

But for some reason, my key shows a TXID that is different from the block height.

Key: `byteskey((67, 0, 0, 0, 0, 236, 58, 152, 94, 229, 61, 50, 239, 22, 75, 88, 246, 154, 181, 7, 146, 209, 249, 113, 25, 180, 120, 10, 150, 150, 112, 118, 209, 0), 98, 112, 112, 118, 209, 095, 112 43, 211, 164, 127, 45, 124, 28, 164, 166, 210, 240, 182, 238, 220, 41, 24, 211, 153, 185, 205, 199))))

TXID: f349b3a497e29738638c27654d3125deb8d90702dc51ab3bc993370900000000

Block 684,608 TXID

I’m getting the XOR obfuscation key:

    let read_opts = ReadOptions::new();
    let xor_iter = db.iter(read_opts);
    let mut obfuscation_key: Vec = Vec::new();

    for (key, value) in xor_iter {
        if key.0.starts_with(&(0x0e)) {
            obfuscation_key = value;
            break;
        }
    }

This returns a decoded value byte as follows: (52, 148, 23, 67, 104 , 115, 134, 222, 130, 10, 78, 153, 93, 115, 228, 159, 196, 86, 17, 179, 224, 72, 222, 228, 185, 255, 26, 46, 229, 73, 140, 125, 129, 241, 246, 106, 170, 3, 94, 35)

But 52 is clearly not the correct byte for block 684,608.

What’s missing?