douyamv/ai_bt_c_bloom

btc-all-addr blocked Bloom filter (15 GiB, k=23)

A blocked Bloom filter over the set of all Bitcoin addresses seen on-chain as of 2026-04-03, stored as a raw bitmap with no header.

Original file: btc-all-addr-20260403-blocked-15G-k23-cpu.bloom Split into 4 parts here purely for upload/download convenience.

Parameters

Total size (m_bytes)	16,106,127,360 bytes (15 GiB) = 128,849,018,880 bits
Block size	256 bytes (2048 bits)
Number of blocks	62,914,560
Hash functions (k)	23
Bit order in byte	LSB-first — byte & (1 << (bit % 8))
File header	none — byte 0 is the start of block 0

Reassembly

cat ai_bt_c_bloom-*.bin > btc-all-addr-20260403-blocked-15G-k23-cpu.bloom
sha256sum btc-all-addr-20260403-blocked-15G-k23-cpu.bloom
# expect: b585c743d1165b7d84b71bb962461039335a9bdc56d02f411daabb8466e839b2

Verified: the concatenation of the 4 parts is byte-identical to the original.

SHA256 of each part

38600123fe207af8c4ccc02cd04271603e9c13bccf523c86dc48d39aae1b6bdd  ai_bt_c_bloom-00001-of-00004.bin
1845bbed430822c760966220e1865a26c2fcdaede3df7b0902585c25a7e8ae87  ai_bt_c_bloom-00002-of-00004.bin
18aecb5032755e61e4685fd7def790a8b4ab06e9439f2746003fb3ca5916bb9b  ai_bt_c_bloom-00003-of-00004.bin
1dd01f5d82a02766d4472b5b05b7469fa0456627902eca6ba928fc9e36bbcb1d  ai_bt_c_bloom-00004-of-00004.bin

Each part is exactly 4,026,531,840 bytes, so part i starts at offset i * 4026531840. Because that offset is a multiple of the 256-byte block size, every part is block-aligned — you can memory-map the parts individually without stitching them together, if you prefer.

Query algorithm

The key is the hash160 of the address (20 bytes): for P2PKH/P2WPKH this is RIPEMD160(SHA256(pubkey)), i.e. the payload of the base58check / bech32 address.

This file uses the parameter family referred to as B in the reference implementation.

// splitmix64 finalizer
fn mix64(mut x: u64) -> u64 {
    x ^= x >> 30;
    x = x.wrapping_mul(0xBF58476D1CE4E5B9);
    x ^= x >> 27;
    x = x.wrapping_mul(0x94D049BB133111EB);
    x ^= x >> 31;
    x
}

// hash160 -> (a, b, c), all little-endian
let a = u64::from_le_bytes(h160[0..8]);
let b = u64::from_le_bytes(h160[8..16]);
let c = u32::from_le_bytes(h160[16..20]) as u64;

// 1. which block
let h = (a.wrapping_mul(0x6C62272E07BB0142) ^ b.wrapping_mul(0x94D049BB133111EB))
        .wrapping_add(c.wrapping_mul(0xBF58476D1CE4E5B9));
let block = mix64(h) % 62_914_560;

// 2. the 23 bit positions inside that 2048-bit block
for k in 0..23u32 {
    let mut h = b ^ 0xC4CEB9FE1A85EC53u64.wrapping_mul((k + 2) as u64);
    h ^= a.wrapping_add(c.wrapping_mul((k + 5) as u64));
    let bit = (mix64(h) % 2048) as u32;

    // 3. test it (LSB-first)
    let byte = bloom[block as usize * 256 + (bit / 8) as usize];
    if byte & (1u8 << (bit % 8)) == 0 {
        return false;   // definitely not in the set
    }
}
return true;            // probably in the set

All arithmetic is wrapping (u64), including c * (k + 5) — do not truncate it to 32 bits.

Note: an earlier written description of this filter had the block-index expression as a*K1 ^ b*K2 + c*K3, which under C operator precedence parses as (a*K1) ^ ((b*K2) + (c*K3)). That reading is wrong — addresses known to be in the set then match only ~5.5/23 bits (i.e. chance level). The correct grouping is (a*K1 ^ b*K2) + c*K3, as written above, which gives 23/23 on known-present addresses.

Caveats

• A Bloom filter answers "definitely not present" or "probably present". Any positive result must be confirmed against a real address set or a full node.
• The builder source that originally produced this file is no longer available; the algorithm above was recovered by probing the filter with addresses known to be present, and is verified to give 23/23 bit hits on all of them.
• Snapshot date is 2026-04-03. Addresses first used after that date are not in the filter.

License

CC0-1.0. The underlying data is derived from the public Bitcoin blockchain.