Crate four_word_networking

Four-Word Networking

Convert network IP addresses into memorable word combinations for human-friendly networking.

Features

• Perfect IPv4: Converts IPv4 addresses like 192.168.1.1:443 into exactly 4 memorable words with 100% perfect reconstruction
• Adaptive IPv6: Converts IPv6 addresses into 6, 9, or 12 words using intelligent compression
• Voice-Friendly: Easy to share over phone calls or voice chat
• Error-Resistant: Much less prone to typos than long technical addresses
• Deterministic: Same IP address always produces the same word combination
• Visual Distinction: Different formatting for IPv4 vs IPv6 addresses
• Universal: Works with any valid IP address format

Examples

Basic Encoding/Decoding

use four_word_networking::FourWordAdaptiveEncoder;

let encoder = FourWordAdaptiveEncoder::new()?;
let address = "192.168.1.1:443";

// Convert to four words (perfect reconstruction for IPv4)
let words = encoder.encode(address)?;
println!("Address: {} -> {}", address, words);

// Decode back to exact address
let decoded = encoder.decode(&words)?;
assert_eq!(address, decoded);

Random Word Generation

use four_word_networking::FourWordAdaptiveEncoder;

let encoder = FourWordAdaptiveEncoder::new()?;

// Generate random dictionary words (NOT IP encodings)
// Useful for passphrases, test data, or any application needing random words
let random_words = encoder.get_random_words(4);
println!("Random words: {}", random_words.join(" "));

// Generate a 6-word passphrase
let passphrase = encoder.get_random_words(6);
println!("Passphrase: {}", passphrase.join("-"));

// All generated words are valid dictionary words
for word in &random_words {
    assert!(encoder.is_valid_word(word));
}

Word Validation

use four_word_networking::FourWordAdaptiveEncoder;

let encoder = FourWordAdaptiveEncoder::new()?;

// Validate user input words
assert!(encoder.is_valid_word("ocean"));
assert!(encoder.is_valid_word("OCEAN")); // Case-insensitive
assert!(!encoder.is_valid_word("xyz123")); // Invalid word

// Get word suggestions for partial input
let hints = encoder.get_word_hints("oce");
assert!(hints.contains(&"ocean".to_string()));

Re-exports

pub use error::FourWordError;

pub use error::Result;

pub use four_word_adaptive_encoder::FourWordAdaptiveEncoder;

pub use four_word_encoder::FourWordEncoder;

pub use four_word_encoder::FourWordEncoding;

pub use four_word_ipv6_encoder::FourWordGroup;

pub use four_word_ipv6_encoder::FourWordIpv6Encoder;

pub use four_word_ipv6_encoder::Ipv6FourWordGroupEncoding;

pub use ipv6_compression::CompressedIpv6;

pub use ipv6_compression::Ipv6Category;

pub use ipv6_compression::Ipv6Compressor;

pub use ipv6_pattern_feistel::IPv6PatternFeistel;

pub use ipv6_pattern_feistel::IPv6PatternId;

pub use ipv6_perfect_patterns::IPv6Pattern;

pub use ipv6_perfect_patterns::IPv6PatternDetector;

pub use pure_ip_compression::MathematicalCompressor;

pub use pure_ip_compression::PureIpCompressor;

pub use universal_ip_compression::UniversalIpCompressor;

Modules

compression

Advanced compression module for IP addresses and ports

dictionary4k

4,096-word dictionary for four-word networking encoding.

error

Error types for four-word networking

four_word_adaptive_encoder

Adaptive four-word encoder that handles both IPv4 and IPv6 addresses.

four_word_encoder

Four-word encoder for IPv4 addresses.

four_word_ipv6_encoder

Four-word encoder for IPv6 addresses.

ipv6_compression

IPv6 Hierarchical Compression Engine

ipv6_pattern_feistel

IPv6 Pattern Feistel Network

ipv6_perfect_patterns

IPv6 Perfect Patterns - BGP-Based Provider Dictionary and Pattern Detection

pure_ip_compression

Pure Mathematical IP+Port Compression

universal_ip_compression

Universal IP+Port Compression for Four Words

validation

Validation and autocomplete functionality for four-word networking.

Constants

VERSION

Version of the four-word networking library