DEV Community: imduchuyyy 🐬

I created a LRU caching server in Rust

imduchuyyy 🐬 — Tue, 06 Jan 2026 07:34:52 +0000

I recently coded a mini caching server in Rust, implementing the LRU (Least Recently Used) mechanism in under 1000 lines of code. By applying zero-copy techniques and careful memory management, I achieved high performance and production-ready stability.

Here is the breakdown of how I built it and why it's so fast.

The Core Design

The heart of the cache is the Cache struct. Instead of using standard pointer-based linked lists (which can be unsafe or slow in Rust due to RefCell overhead), I used a vector-based arena allocator approach.

Key Data Structures

Zero-Copy with bytes::Bytes:
I used bytes::Bytes for both keys and values. This is a crucial optimization. Bytes acts as a reference-counted slice of memory (similar to Arc<[u8]>). When we clone a Key or Value, we aren't copying the underlying data; we are just incrementing a reference count. This makes passing data around extremely cheap.
Index-based Linked List:
The LRU queue is implemented as a double-linked list, but nodes are stored in a Vec<Entry>. The prev and next pointers are simply u32 indices into this vector.
- Memory Efficiency: No memory fragmentation from allocating individual nodes.
- Cache Locality: The Vec keeps entries close in memory, improving CPU cache hits.

type Key = Bytes;
type Value = Bytes;
type Index = u32;

#[derive(Debug)]
struct Entry {
    key: Key,
    value: Value,
    prev: Option<Index>,
    next: Option<Index>,
}

#[derive(Debug)]
pub struct Cache {
    capacity: usize,
    map: HashMap<Key, Index>, // Maps Key -> Index in the entries vector
    entries: Vec<Entry>,      // The "Arena"
    head: Option<Index>,      // MRU (Most Recently Used)
    tail: Option<Index>,      // LRU (Least Recently Used)
    free: Vec<Index>,         // Reusable slots
}

How It Works

The `get` Operation: O(1)

When retrieving an item, we look up the index in the HashMap. If found, we move the node to the head of the list (marking it as most recently used) and return a cheap clone of the value.

pub fn get(&mut self, key: &Key) -> Option<Value> {
    let idx = *self.map.get(key)?;
    self.move_to_head(idx);
    Some(self.entries[idx as usize].value.clone()) // Zero-copy clone!
}

The `put` Operation: O(1)

Inserting a value handles three cases:

Update: If the key exists, update value and move to head.
Insert (Full): If capacity is reached, evict the tail (LRU), reuse its slot, and insert the new item at the head.
Insert (Space Available): Allocate a new slot (or reuse a freed one) and insert at the head.

The eviction logic is particularly clean because we can directly reuse the index from the evicted tail for the new entry, avoiding reallocation.

pub fn put(&mut self, key: Key, value: Value) {
    if let Some(&idx) = self.map.get(&key) {
        self.entries[idx as usize].value = value;
        self.move_to_head(idx);
        return;
    }

    if self.map.len() == self.capacity {
        self.evict();
    }

    let idx = self.alloc(Entry {
        key: key.clone(),
        value,
        prev: None,
        next: None,
    });

    self.map.insert(key, idx);
    self.attach_head(idx);
}

Benchmarks

I ran a benchmark on my local machine to test the raw throughput of the cache implementation (excluding network overhead). The results are impressive:

Environment: cargo run --release, MacBook Pro (Apple Silicon).
Parameters: 500k Capacity, 1M Operations.

Operation	Throughput	Latency (Total)
PUT (Insert)	~5.38 Million ops/sec	185ms (for 1M items)
GET (Hit)	~12.09 Million ops/sec	8.27ms (for 100k items)
GET (Miss)	~6.98 Million ops/sec	14.33ms (for 100k items)

The use of Bytes and the index-based approach yields massive performance benefits, making this simple implementation competitive with production-grade systems.

The Server

Finally, I wrapped this Cache in an HTTP server using axum. To share the cache across threads, I used Arc<Mutex<Cache>>. While the Mutex introduces some contention, the raw speed of the underlying cache keeps the critical section extremely short.

use axum::{
    extract::{Path, State},
    routing::get,
    Router,
    body::Bytes,
};
use std::sync::{Arc, Mutex};
use std::env;

type SharedCache = Arc<Mutex<Cache>>;

#[tokio::main]
async fn main() {
    let capacity: usize = env::var("CAPACITY")
        .unwrap_or_else(|_| "100".to_string())
        .parse()
        .expect("CAPACITY must be a number");

    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("127.0.0.1:{}", port);
    let shared_cache = Arc::new(Mutex::new(Cache::new(capacity)));

    let app = Router::new()
        .route("/{key}", 
            get(handle_get).put(handle_put)
        )
        .with_state(shared_cache);

    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
    println!("Simple Cache Server running on {}", addr);
    axum::serve(listener, app).await.unwrap();
}

The source code is available on GitHub.

CryptEnv: Secure Your Environment Variables 🔐

imduchuyyy 🐬 — Wed, 26 Feb 2025 08:17:03 +0000

As developers, we often rely on .env files to manage sensitive environment variables. But have you ever thought about how insecure this practice is? .env files store secrets in plain text, making them vulnerable to accidental leaks, unauthorized access, or exposure in public repositories.

That’s why I built CryptEnv – a simple yet powerful tool that lets you securely store, manage, and use environment variables without exposing them in plaintext.

🚀 Why You Need CryptEnv

✅ No More Plaintext Secrets – Store your environment variables in an encrypted, global base store instead of a raw .env file.

✅ On-Demand Decryption – Your secrets are only decrypted when needed, and you must unlock them using a password before accessing them.

✅ Auto-Clearing Environment – Once your process finishes, CryptEnv automatically clears the variables, leaving no trace behind.

✅ Easy Integration – Works seamlessly with any programming language or framework that uses environment variables.

✅ Open Source – Completely free and available for the community! Check it out on GitHub: CryptEnv Repository

🔧 How CryptEnv Works

1️⃣ Store your secrets securely

crypt-env set DATABASE_URL "postgres://user:password@host/db"

2️⃣ Unlock and use them in your process

crypt-env exec "node app.js"

3️⃣ Environment variables are cleared after the process ends

That’s it! No more insecure .env files lying around.

🔥 Who Should Use CryptEnv?

💡 Backend Developers – Prevent secret leaks in code repositories.

🔒 DevOps & Security Engineers – Improve security posture by eliminating plaintext secrets.

📦 Open Source Contributors – Keep credentials safe while working in public repositories.

💻 Anyone Using .env Files – If you’re using .env, you need CryptEnv.

📌 Get Started Today!

Ready to level up your environment variable security? Try CryptEnv now! 🚀

🔗 GitHub Repository

If you like this project, consider starring it on GitHub ⭐ and sharing it with your fellow developers!

Let’s build secure and privacy-focused applications together! 🔐

How to Create Your First Wallet in Web3 with just ... a touch

imduchuyyy 🐬 — Thu, 01 Aug 2024 04:55:38 +0000

Welcome to the future of the internet! Abstraction Wallet is your gateway to the decentralized world of Web3. Designed with user-friendliness and top-notch security in mind, Abstraction Wallet empowers you to manage your digital assets seamlessly. Whether you’re a seasoned crypto enthusiast or just starting your journey, our wallet provides the tools and features you need to thrive in the blockchain ecosystem.

Creating your first crypto wallet with Abstraction Wallet is simple and secure. Follow these easy steps to get started on your Web3 journey. (And you don't need to install anything)

Step 1: Redirect to Abstraction Wallet

First, open your web browser and go to wallet.abstraction.world. This is the official site for Abstraction Wallet, where you can create and manage your on-chain wallets securely.

Step 2: Type the Name of Your Passkey and Click “Create New Wallet”

Once you’re on the website, you’ll see a field where you can enter the name of your passkey. This is simply the name that will be used to store the passkey on your device. Choose a name that’s easy for you to remember. After entering the name, click on the “Create Wallet” button

Step 3: Select Where to Store Your Passkey and Touch the TouchID Button

Next, you need to decide where to store your passkey. For enhanced experience, we recommend using iCloud Backup (for Apple devices) if your device supports it. Select the appropriate option and touch the TouchID button to complete this step.

Important: Keep in mind that your passkey will be stored only on your device, and only you can access your wallet. This ensures maximum security and privacy for your digital assets.

Step 4: Congratulations, Your Wallet Has Been Created!

And that’s it! You’ve successfully created your first Web3 wallet with Abstraction Wallet. You’ll see a confirmation message on your screen. Now you can start exploring the world of cryptocurrencies, send and receive tokens, and manage your digital assets with ease.

What’s Next?

Now that you have your wallet set up, here are a few things you can do next:

Check your balance: See the tokens and NFTs you own.
Send tokens: Easily transfer tokens to other addresses.
Buy/Sell tokens and NFTs: Engage in trading to grow your portfolio.

Thank you for choosing Abstraction Wallet. If you have any questions or need further assistance, feel free to contact me.

Happy crypto journey!

Passkey and Account Abstraction - Next generation of crypto wallet

imduchuyyy 🐬 — Tue, 23 Jul 2024 03:31:51 +0000

TL;DR

The evolution of digital wallets has been remarkable, driven by the need for security, user-friendliness, and advanced functionalities. As we move into the next phase of crypto wallet development, two emerging technologies, passkeys and account abstraction, promise to significantly enhance user experience and security. In this article, we will explore how these technologies, underpinned by the ERC-4337 standard, are set to revolutionize crypto wallets.

Understanding Passkeys

What Are Passkeys?

Passkeys are a form of digital authentication that replaces traditional passwords. They are designed to be more secure and user-friendly, leveraging public-key cryptography to authenticate users. Unlike passwords, passkeys are resistant to common attacks such as phishing and brute force.

How Do Passkeys Work?

Passkeys work by creating a pair of cryptographic keys: a public key and a private key. The public key is stored on the server, while the private key remains securely on the user’s device. When a user needs to authenticate, the private key signs a challenge, which is then verified by the public key on the server.

Benefits of Passkeys

Enhanced Security: Since the private key never leaves the user’s device, it is less susceptible to interception or theft.
User Convenience: Users no longer need to remember complex passwords, making the authentication process quicker and simpler.
Phishing Resistance: Passkeys are immune to phishing attacks because they do not rely on shared secrets.

The Role of Account Abstraction

What is Account Abstraction?

Account abstraction in the context of Ethereum and blockchain technology refers to the process of decoupling the traditional externally owned account (EOA) model from the execution environment. It allows for more flexible account management and advanced functionalities, enabling smart contracts to have similar capabilities as user accounts.

How Does Account Abstraction Work?

Account abstraction works by enabling smart contracts to act as accounts, allowing them to initiate transactions and interact with other contracts autonomously. This is facilitated by the ERC-4337 standard, which introduces a new way of handling transactions that do not rely solely on EOAs.

Benefits of Account Abstraction

Flexibility: Allows for the creation of more sophisticated wallet functionalities and user experiences.
Security: Enhances security by enabling multi-signature wallets and other advanced security measures.
Automation: Enables automation of transactions and interactions within the blockchain, reducing the need for constant user intervention.

How Passkeys and Account Abstraction Complement Each Other

The combination of passkeys and account abstraction is set to offer a seamless and secure user experience. Passkeys ensure that users can authenticate securely and conveniently, while account abstraction allows for more sophisticated wallet functionalities and enhanced security measures.

Enhanced User Experience

Seamless Authentication: Passkeys provide a quick and secure way to access wallets without the hassle of passwords.
Advanced Wallet Features: Account abstraction enables features like multi-signature approvals, automatic transaction execution, and more.

Improved Security

Phishing-Resistant Authentication: Passkeys mitigate phishing risks, ensuring that only the rightful owner can access the wallet.
Robust Security Measures: Account abstraction allows for the implementation of advanced security features, making wallets more resilient to attacks.

Introducing Abstraction Wallet

At Abstraction Wallet, we are at the forefront of integrating these cutting-edge technologies. Our wallet leverages the power of passkeys and account abstraction to provide users with a next-generation experience. Here’s how:

Abstraction Wallet Features

Secure Authentication: Utilizing passkeys, Abstraction Wallet ensures that your private keys remain secure on your device, providing a robust defense against phishing and hacking attempts
Flexible Account Management: With account abstraction, users can enjoy advanced functionalities like multi-signature approvals, automated transactions and devices management.
User-Friendly Interface: Our wallet is designed to be intuitive and easy to use, removing the complexity often associated with crypto wallets.
ERC-4337 Compatibility: Abstraction Wallet is built on the ERC-4337 standard, ensuring that our users have access to the latest in blockchain innovation

Why Choose Abstraction Wallet?

State-of-the-Art Security: Our use of passkeys and account abstraction provides unparalleled security
Enhanced User Experience: We prioritize user convenience without compromising on security.
Future-Proof: Built with ERC-4337, Abstraction Wallet is ready for the future of blockchain technology

Create your first passkey-account-abstraction wallet here: https://wallet.abstraction.world
Mint our NFT: Mint NFT using Abstraction Wallet

Conclusion

As the crypto space continues to evolve, the adoption of passkeys and account abstraction, particularly with the support of ERC-4337, is poised to redefine the landscape of crypto wallets. These technologies promise to deliver a new generation of wallets that are not only more secure but also more user-friendly and feature-rich. By understanding and embracing these innovations, users can look forward to a more secure and convenient experience in managing their digital assets.

By integrating passkeys and account abstraction into crypto wallets, we are paving the way for a more secure, efficient, and user-friendly future. Keep an eye on these developments as they continue to shape the world of digital finance.