kuro/tri/encoding.tri

// Byte <-> tower element encoding.
//
// Converts between raw U32 words (representing little-endian byte packing)
// and F₂ tower field elements. Each tower level has a natural byte width:
//   F₂¹²⁸ = 16 bytes (4 × U32), F₂⁶⁴ = 8 bytes (2 × U32),
//   F₂³² = 4 bytes (1 × U32), etc.
//
// In Trident, bytes are packed into U32 words in little-endian order.
// The U32 words themselves are ordered little-endian (w0 = least significant).

module kuro.encoding

use kuro.tower.*

/// Encode 4 × U32 (16 bytes little-endian) as an F₂¹²⁸ element.
pub fn encode_128(w0: U32, w1: U32, w2: U32, w3: U32) -> F2_128 {
    F2_128 { w0: w0, w1: w1, w2: w2, w3: w3 }
}

/// Decode an F₂¹²⁸ element to 4 × U32 (little-endian words).
pub fn decode_128_w0(a: F2_128) -> U32 { a.w0 }
pub fn decode_128_w1(a: F2_128) -> U32 { a.w1 }
pub fn decode_128_w2(a: F2_128) -> U32 { a.w2 }
pub fn decode_128_w3(a: F2_128) -> U32 { a.w3 }

/// Encode 2 × U32 (8 bytes little-endian) as an F₂⁶⁴ element.
pub fn encode_64(lo: U32, hi: U32) -> F2_64 {
    F2_64 { lo: lo, hi: hi }
}

/// Decode an F₂⁶⁴ element to 2 × U32.
pub fn decode_64_lo(a: F2_64) -> U32 { a.lo }
pub fn decode_64_hi(a: F2_64) -> U32 { a.hi }

/// Encode 1 × U32 (4 bytes little-endian) as an F₂³² element.
pub fn encode_32(w: U32) -> F2_32 { F2_32 { val: w } }

/// Decode an F₂³² element to U32.
pub fn decode_32(a: F2_32) -> U32 { a.val }

/// Encode low 16 bits of a U32 as an F₂¹⁶ element.
pub fn encode_16(w: U32) -> F2_16 { F2_16 { val: w & 0xFFFFu32 } }

/// Decode an F₂¹⁶ element to U32 (upper 16 bits zero).
pub fn decode_16(a: F2_16) -> U32 { a.val & 0xFFFFu32 }

/// Encode low 8 bits of a U32 as an F₂⁸ element.
pub fn encode_8(w: U32) -> F2_8 { F2_8 { val: w & 0xFFu32 } }

/// Decode an F₂⁸ element to U32 (upper 24 bits zero).
pub fn decode_8(a: F2_8) -> U32 { a.val & 0xFFu32 }

/// Encode low 4 bits of a U32 as an F₂⁴ element.
pub fn encode_4(w: U32) -> F2_4 { F2_4 { val: w & 0x0Fu32 } }

/// Decode an F₂⁴ element to U32 (upper 28 bits zero).
pub fn decode_4(a: F2_4) -> U32 { a.val & 0x0Fu32 }