the source

the code that runs inside every transfer of the token.

the program is a single rust file of roughly eight hundred lines. it is compiled with anchor against solana's bpf target and deployed to the mainnet bpf upgradeable loader with the upgrade authority revoked in the same session. the sealed bytecode is what runs forever.

the layout

the program maintains three program derived addresses, each with a fixed account layout. the first holds the circular buffer of recent transfers. the second holds the running kolmogorov complexity estimate and the lempel-ziv dictionary state. the third is the vault.

// account layouts for the kolmogorov transfer hook program

const BUFFER_LEN: usize = 512;
const TUPLE_BYTES: usize = 22;          // (slot:8, src:4, dst:4, amount:4, price:2)
const FP_SCALE: i128 = 1_000_000_000_000;
const K_REFERENCE_FP: i128 = 853_000_000_000;  // 0.853 * 1e12

#[account]
pub struct TradeBuffer {
    pub mint: Pubkey,
    pub head: u16,                          // circular write pointer
    pub filled: u16,                        // entries (caps at BUFFER_LEN)
    pub last_update_slot: u64,
    pub entries: [u8; BUFFER_LEN * TUPLE_BYTES],
}

#[account]
pub struct ComplexityState {
    pub mint: Pubkey,
    pub last_k_estimate_fp: i128,            // current K(x), 1e12 fixed-point
    pub lz_dict_size: u32,                   // size of current LZ dictionary
    pub last_compute_unit_cost: u32,         // for diagnostics
    pub last_update_slot: u64,
}

#[account]
pub struct VaultState {
    pub mint: Pubkey,
    pub accumulated_lamports: u64,
    pub last_deposit_slot: u64,
    pub total_distributed: u128,
    pub bump: u8,
}

the entry point

the transfer hook is the only entry point. it is invoked by the token-2022 program every time the kolmogorov mint participates in a transfer. the hook reads the active price from the bonding curve, appends the tuple to the circular buffer, recomputes the complexity estimate, and returns the surcharge to be withheld. all of this executes atomically inside the transfer's transaction.

// the transfer hook entry point

pub fn execute(ctx: Context<Execute>, amount: u64) -> Result<u64> {
    let clock = Clock::get()?;
    let buf = &mut ctx.accounts.trade_buffer;
    let cx = &mut ctx.accounts.complexity_state;
    let vault = &mut ctx.accounts.vault;

    // 1. read active price from the bonding curve
    let price_fp = read_bonding_curve_price(&ctx.accounts.curve_state)?;

    // 2. encode the tuple and append to the circular buffer
    let tuple = encode_tuple(
        clock.slot,
        ctx.accounts.source.owner,
        ctx.accounts.destination.owner,
        amount,
        price_fp,
    );
    let head = buf.head as usize;
    let start = head * TUPLE_BYTES;
    buf.entries[start..start + TUPLE_BYTES].copy_from_slice(&tuple);
    buf.head = ((head + 1) % BUFFER_LEN) as u16;
    if (buf.filled as usize) < BUFFER_LEN {
        buf.filled += 1;
    }

    // 3. recompute the kolmogorov complexity estimate via streaming LZ
    let k_fp = streaming_lz_complexity(&buf.entries[..(buf.filled as usize * TUPLE_BYTES)]);
    cx.last_k_estimate_fp = k_fp;

    // 4. compute surcharge from squared deviation against the reference
    let dev = k_fp - K_REFERENCE_FP;
    let dev_sq_fp = (dev * dev) / FP_SCALE;
    let surcharge_rate_fp = (SURCHARGE_K_COEFF * dev_sq_fp) / FP_SCALE;
    let surcharge = ((amount as i128 * surcharge_rate_fp) / FP_SCALE)
        .max(0)
        .min(amount as i128) as u64;

    // 5. accumulate in the vault
    vault.accumulated_lamports = vault.accumulated_lamports.saturating_add(surcharge);
    vault.last_deposit_slot = clock.slot;

    Ok(surcharge)
}

the compression

the kolmogorov complexity of the buffer is approximated using a streaming variant of the lempel-ziv 77 algorithm. the algorithm walks through the buffer one byte at a time, building a dictionary of previously seen substrings, and emits the length of the dictionary as the upper bound on the complexity. the result is normalized to the interval zero to one by dividing the dictionary length by the buffer length. the entire pass runs in under one hundred fifty thousand compute units on solana, well inside the program's budget.

// streaming lempel-ziv 77 complexity estimator
// returns K(x) ∈ [0, 1] as i128 fixed-point with FP_SCALE = 1e12

fn streaming_lz_complexity(data: &[u8]) -> i128 {
    if data.is_empty() {
        return 0;
    }
    let mut dict_entries: u32 = 0;
    let mut i: usize = 0;
    let n = data.len();
    while i < n {
        // find the longest prefix of data[i..] that occurred before position i
        let mut best_len = 0usize;
        let mut search_start = i.saturating_sub(WINDOW_SIZE);
        for j in search_start..i {
            let max_match = (n - i).min(i - j);
            let mut k = 0;
            while k < max_match && data[j + k] == data[i + k] {
                k += 1;
            }
            if k > best_len {
                best_len = k;
            }
        }
        // emit one dictionary entry; advance by at least 1 byte
        dict_entries += 1;
        i += best_len.max(1);
    }
    // normalize to [0, 1] in fixed point: K = dict_entries / n
    (dict_entries as i128 * FP_SCALE) / (n as i128)
}

the three functions above are the entire protocol. the rest of the file is account setup, error definitions, and the math for the bonding curve price read. there is nothing else hidden in the binary.