DEV Community: Abdul-Qawi Laniyan

[Boost]

Abdul-Qawi Laniyan — Sun, 11 Jan 2026 20:37:02 +0000

Wallets Are the New Auth Layer

Abdul-Qawi Laniyan ・ Jan 11

Wallets Are the New Auth Layer

Abdul-Qawi Laniyan — Sun, 11 Jan 2026 20:36:37 +0000

If you have implemented authentication in Web2, Web3 wallets should not feel strange.
They solve the same problem using a cleaner trust model.

Authentication has always been about one thing: Can this user prove control over an identity?

Web3 does not change the question, it simply changes who stores the proof.

Web2 Authentication Is Stateful by Design

PS: stateful means applications remember information (its "state") from past interactions, using that context to process new requests

In Web2, identity lives on your servers.

A typical login flow:

User submits email and password
Backend validates against stored credentials
Session or JWT is issued

Even OAuth follows the same structure:

Identity is asserted by Google or GitHub
Your system trusts a third party as the source of truth

This creates three structural properties:

Secrets must be stored
Identity is platform-bound
The backend is responsible for protection and recovery

Most Web2 auth problems are not mistakes they are simply consequences of this model.

Wallet Authentication Removes Stored Secrets

Wallet-based auth flips the architecture. There is no password, no credential database, and no identity provider.

A wallet is just a key pair:

Public key (address) → user identifier
Private key → proof of control

Authentication is done by signing data, not submitting secrets.

The Wallet Login Flow

Here is the exact flow, expressed in terms a Web2 engineer already understands:

Server generates a random challenge (nonce)
Client asks the wallet to sign the nonce
Server verifies the signature using the wallet address

If verification passes, the user is authenticated.

This is public-key authentication. The same model used by SSH.
You can read in detail here

Little example

// server
const nonce = generateRandomNonce();
storeNonce(address, nonce);

// client
const signature = wallet.signMessage(nonce);

// server
const isValid = verifySignature({
  address,
  nonce,
  signature
});

if (isValid) {
  authenticateUser(address);
}

No password comparison, secrets stored, simply cryptographic verification.

Why This Is Decentralization in Practice

This is where decentralization stops being philosophical.

Users own their identity
Platforms cannot silently revoke access
One identity works across many applications

The backend no longer controls authentication. It only verifies math.

What Wallets Do Not Solve

As great as this is, it doesn't solve all problems.

Wallets:

Solve authentication
Do not solve authorization
Do not manage user profiles
Do not prevent key loss

You still need:

Role management
Permissions
Application-level user data

Wallets replace login systems, not the application logic.

If you remember one thing, remember this:

Wallets are SSH keys for users instead of servers.

Once you view them that way, wallet-based auth stops being exotic
and starts looking like an obvious evolution of identity systems.

Whisper Board: Building a Private, Decentralized Messaging Experience with Waku

Abdul-Qawi Laniyan — Mon, 03 Nov 2025 23:11:00 +0000

Decentralized messaging is the future of censorship-resistant, privacy-first communication.

Whisper Board is a lightweight, anonymous chat app powered by Waku protocol, designed to showcase how easy it is to integrate Waku into a modern web stack.

Here is the repo and live app

Why Decentralized Messaging?

Most recently, we've seen how fragile centralized systems can be. A single AWS outage in the US-East region, knocked out major apps, even Signal, a privacy-first messenger, across Central and Eastern Europe. Billions of messages delayed, communities cut off, and trust shaken.
Here is a full report on what happened.

When all communication routes depend on a few corporate data centers, resilience becomes an illusion.

Decentralized messaging changes that: it doesn’t rely on one server, company, or geography. Messages flow peer-to-peer, so even if one node fails, the network stays alive. It’s more than just privacy, it’s about robustness, autonomy, and continuity.

In this article, you'll learn:

The architecture behind a simple Whisper Board built with waku
How to connect to and use Waku in your own app
How messages flow through the network
How to onboard and contribute as a new developer
Visual diagrams to aid understanding

Architecture Overview

Diagram: System Components

File structure :

src
├── components
│   ├── MessageCard.tsx
│   └── MessageForm.tsx
├── hooks
├── lib
├── pages
│   ├── Index.tsx
│   └── NotFound.tsx
├── services
│   ├── MessageService.ts
│   └── WakuService.ts
├── types
├── App.css
├── App.tsx
├── index.css
├── main.tsx
├── vite-env.d.ts
.gitignore
bun.lockb
components.json
eslint.config.js
index.html
package-lock.json
package.json
postcss.config.js
README.md
tailwind.config.ts
tsconfig.app.json
tsconfig.json
tsconfig.node.json
vite.config.ts
</pre>

Frontend: Built in React, styled with Tailwind and shadcn-ui.
Hooks: useWaku handles node connection, useMessages manages sending/receiving.
Services: WakuService manages the Waku node, MessageService handles message flow.
Waku Node: Lightweight node connects to the decentralized network.

Technologies Used

- Vite
- TypeScript
- React
- shadcn-ui
- Tailwind CSS
- Waku JS SDK

How the App Works

Connecting to Waku

The custom hook useWaku.ts initializes and manages the Waku node:

const { isConnecting, isConnected, error } = useWaku();

On mount, calls wakuService.initialize() to connect to Waku peers.
Cleans up on unmount via wakuService.stop().

Code Reference

//src/hooks/useWaku.ts 
/* https://github.com/Oladotunlaniyan/whisper-waku-chat/blob/main/src/hooks/useWaku.ts*/

import { useState, useEffect } from "react";
import { wakuService } from "../services/WakuService";

export const useWaku = () => {
  const [isConnecting, setIsConnecting] = useState(false);
  const [isConnected, setIsConnected] = useState(false);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const initWaku = async () => {
      if (wakuService.isReady()) {
        setIsConnected(true);
        return;
      }
      setIsConnecting(true);
      setError(null);
      try {
        await wakuService.initialize();
        setIsConnected(true);
      } catch (err) {
        setError(err instanceof Error ? err.message : "Failed to connect to Waku");
      } finally {
        setIsConnecting(false);
      }
    };
    initWaku();
    return () => {
      wakuService.stop();
    };
  }, []);
  return { isConnecting, isConnected, error };
};

Messaging Flow

Sequence Diagram: Sending and Receiving a Message

Core Flow

User submits a message via the UI (MessageForm).
Hook useMessages calls messageService.publishMessage.
MessageService encodes and pushes the message to the Waku network.
Node listens for incoming messages and updates UI in real time.

Key Code References

//name=src/services/MessageService.ts 
export class MessageService {
  private getEncoder() {
    const node = wakuService.getNode();
    return node.createEncoder({ contentTopic: CONTENT_TOPIC });
  }
  async publishMessage(content: string): Promise<void> {
    const node = wakuService.getNode();
    const encoder = this.getEncoder();
    const message = { content, timestamp: Date.now() };
    const payload = this.encodeMessage(message);
    await node.lightPush.send(encoder, { payload });
  }
  async subscribeToMessages(onMessage: (message: WhisperMessage) => void): Promise<() => void> {
    const node = wakuService.getNode();
    const decoder = this.getDecoder();
    await node.filter.subscribe([decoder], (wakuMessage) => {
      if (!wakuMessage.payload) return;
      const decoded = this.decodeMessage(wakuMessage.payload);
      onMessage({ id: `${decoded.timestamp}-${Math.random()}`, content: decoded.content, timestamp: decoded.timestamp });
    });
    return () => { /* unsubscribe logic */ };
  }
}

Onboarding: Steps for Beginner Contributors

Getting Started

Clone the Repository

git clone https://github.com/Oladotunlaniyan/whisper-waku-chat.git
cd whisper-waku-chat

Install Dependencies

npm install

Run the App

npm run dev

Open http://localhost:8080 in your browser.

Edit Code Locally
- Most logic lives in src/
- Message logic: src/services/MessageService.ts
- Waku node logic: src/services/WakuService.ts
- UI: src/components/, src/pages/

Contribution Guide

Follow the onboarding steps above for local development.
Make sure you have Node.js and npm installed (guide).
Follow the onboarding steps above for local development.
Submit issues or pull requests for improvements, bug fixes, or new features.
For UI tweaks, edit files in src/components/.
For protocol logic, edit src/services/WakuService.ts and src/services/MessageService.ts.

First-Time Contributor Tips

Start by reading the README.
Use the hooks and services as your entry points for understanding message flow.
To add a feature, create a new component in src/components/ and integrate with hooks/services.
For debugging, use console logs in services and hooks.
Ask for help or suggestions via GitHub Issues.

Visuals

System Architecture Diagram (see above)
Sequence Diagram for Messaging (see above)
UI Screenshot: (Add your own screenshot or generate one from running the app.)

Conclusion

Whisper Waku Chat is a simple but powerful demo of decentralized, anonymous messaging using Waku.

With a modern React frontend and the Waku JS SDK, it’s easy for new developers to get started and contribute.

Next Steps:

Fork the repo, run locally, and start hacking!
Check out the Waku docs for protocol details.
Join the Waku dev community for support and collaboration.

Further Resources

This is a very simple implementation of the Waku protocol, in subsequent articles I will be increasing functionality and complexity of the whisper board. This includes using new methods, explaining more core concepts etc.

RealFi is the financial revolution we need

Abdul-Qawi Laniyan — Tue, 14 Oct 2025 16:03:19 +0000

Communities are living ecosystems, and at the core of every thriving ecosystem is finance. From the small market women pooling savings to fund each other’s businesses, to migrants sending money home to sustain families, finance is the invisible current that keeps societies alive. But for too long, that current has been controlled by centralized institutions, slow, costly, and often out of reach for the people who need it most.

In a small Nigerian town, Fatima, a trader, once waited two days for her remittance to arrive from her son abroad, losing part of it to transfer fees. In Kenya, a women’s cooperative tracked daily savings with handwritten ledgers, hoping no error would erase months of effort. For millions like them, finance has long felt like a wall instead of a bridge. RealFi is tearing down that wall - one community at a time.

What does RealFi Really Mean

RealFi stands for real-world finance, financial tools built on emerging technology like Web3, designed to work in real life. It’s about giving people access to fair, transparent, and community-owned systems that help them save, send, and grow money.

Unlike speculative crypto projects, RealFi focuses on utility, not hype, simply empowering people, not platforms. It brings finance back to the people, ensuring that every transaction builds trust, ownership, and opportunity.

RealFi is already changing our communities

Across the world, RealFi tools are already rewriting the financial story.

In Kenya, women’s savings groups are using blockchain-powered apps like Kotani Pay to pool funds and distribute microloans transparently, reducing mistrust and record-keeping errors.
In the Philippines, migrant workers are sending remittances home in seconds through stablecoin wallets, bypassing the high fees that used to cut into their families’ income.
In Brazil, small business owners are accessing community-backed microloans using decentralized finance protocols like Goldfinch, which connects global lenders to local entrepreneurs without requiring a traditional bank.

Each of these communities is proof that finance doesn’t have to be controlled from the top down, it can grow from the ground up, rooted in cooperation and transparency.

Money has always been a shared story, a belief that something has value because people trust it does. Over time, that story was captured by systems serving institutions more than individuals. Fees, friction, and exclusion became the price of “trust.”

RealFi rewrites that story. With Web3 and decentralization, people are no longer just users of financial systems, they become stakeholders.

Smart contracts replace middlemen.
Tokens replace gatekeepers.
Communities become the new institutions of finance.

The result is ownership. People can finally control their savings, credit, and future without waiting for permission.

The Heart of RealFi

RealFi is awesome, but it isn’t about replacing the old system overnight; it’s about reimagining it. It’s finance that works for real people in real places, from the mother receiving a fair remittance to the student raising funds for school through a global cooperative.

As Web3 continues to evolve, RealFi’s success won’t be measured in token prices or hype, but in lives changed:

A farmer accessing fair credit.
A trader saving securely.
A family finally in control of their future.

That’s the promise of RealFi, finance that belongs to the people, built by the people, for the people.

Why It Matters

Projects supported by Funding the Commons are showing how technology and community collaboration can make finance fair again. By focusing on access, sovereignty, and collective strength, RealFi ensures that progress isn’t just digital — it’s deeply human.

Why Whisper Failed and How Waku is Building the Future of Web3 Communication

Abdul-Qawi Laniyan — Mon, 15 Sep 2025 08:03:23 +0000

Blockchain technology is powerful, but it doesn’t inherently guarantee privacy. It offers pseudonymous transactions {the use of a fictitious or false name (a pseudonym) instead of a real, legal name to engage in online activities.

When Ethereum was first conceived, its creators envisioned more than just a decentralized financial system. They imagined a complete ecosystem where computation, storage, and communication could take place without central control the "holy trinity" of censorship resistance. To achieve this, three core technologies were introduced:

Ethereum for decentralized computation
Swarm for decentralized storage
Whisper for peer-to-peer communication

Whisper: The First Attempt at Decentralized Messaging

Whisper was designed to enable private, censorship-resistant messaging between users and decentralized applications (dApps). At its core, it allowed encrypted messages to be sent across a distributed network, ensuring anonymity and resistance to surveillance.

However, its design quickly showed limitations. Every node in the network had to process every single message, regardless of relevance. While this approach was simple, it became:

Resource-heavy – excessive bandwidth and storage usage
Mobile-unfriendly – drained battery and consumed resources
Spam-prone – no effective protection against malicious traffic

As adoption grew, these flaws became unbearable. Whisper was ambitious, but its lack of scalability prevented it from being viable in real-world applications.

👉 Read more about Whisper here

The Birth of Waku

Recognizing Whisper’s shortcomings, Vac — the research arm of Status, introduced Waku in 2018 as its successor. Waku started as a fork of Whisper, preserving its core ideas but re-engineering the design for practicality.

Waku v1: A Bridge Protocol

Released in 2020, Waku v1 kept much of Whisper’s architecture but stripped away unnecessary complexity. This made it easier for developers experimenting with Whisper to migrate their applications without starting over. However, it was only a stepping stone. The architectural flaws of Whisper were too deep, and the ecosystem needed a more radical redesign.

Waku v2: A Complete Rewrite

The real breakthrough came with Waku v2, a full redesign of the protocol. Instead of broadcasting every message to every node, Waku v2 adopted libp2p GossipSub for message dissemination.

Important clarification: In GossipSub, all nodes still relay messages, but the protocol optimizes dissemination to avoid duplication and reduce overhead. Waku achieves true scalability by combining GossipSub with sharding, which splits the network into smaller subsets. While many nodes may subscribe to all shards, sharding helps reduce bandwidth requirements across the network.

Waku v2 also introduced modularity. Instead of being a single monolithic protocol, Waku became a family of protocols tailored for different communication needs:

Relay – efficient message broadcasting via GossipSub
Store – offline messaging with store-and-forward
Filter – lets light clients only receive relevant messages
RLN (Rate Limiting Nullifiers) – spam resistance while preserving privacy
Lightpush – allows light clients to push messages without running a full relay node
SDS (Scalable Data Sync) – enables efficient synchronization of structured data

This modular design gives developers flexibility. Whether building a real-time chat app, notification system, or DAO coordination tool, Waku v2 provides the right building blocks.

The Waku Network

Waku v2 powers the Waku Network, a communication service network that integrates multiple Waku protocols into production-ready infrastructure.

The Waku Network leverages RLN protection to ensure spam resistance while maintaining privacy. By running Waku nodes, developers and users contribute to a censorship-resistant, privacy-preserving communication layer for Web3.

Why Waku Matters

Whisper was the first bold attempt at decentralized communication, but scalability limited its impact. Waku builds on that vision, evolving it into a practical, modular, and production-ready protocol family. With the Waku Network live, developers now have a strong foundation to embed secure, censorship-resistant messaging into their dApps.

Get Started With Waku

If you’re building in Web3, now is the time to explore Waku:

👉 Check out the Vac RFCs to dive deeper into protocol specifications.

👉 Explore the Waku Network and learn how you can run a node.

👉 Install the Waku SDKs – js-waku for JavaScript/TypeScript, or nim-waku for Nim-based implementations.

👉 Experiment with integrating Waku into your dApps for messaging, notifications, or coordination.

👉 Explore example apps – check out waku-examples for hands-on demos like chat apps and pub/sub messaging.

👉 Join the developer community – follow discussions, ask questions, and stay updated on new RFCs via Vac’s RFC hub

Decentralization is not just about money – it’s about communication, too. Waku is making that vision real, you can go through the official docs here for more research/technical depth.

How Codex Storage Could Redefine Healthcare Data Security and Privacy

Abdul-Qawi Laniyan — Tue, 26 Aug 2025 15:37:45 +0000

Healthcare systems around the world struggle with a core challenge: How to store sensitive patient data securely while still making it easily accessible when needed.

Medical records are sensitive, containing personal health information (PHI) that demands stringent security and privacy measures. Traditional centralized systems often face challenges like data breaches, interoperability issues, and limited patient control. Patients frequently struggle to access their own records or share them seamlessly with healthcare providers across institutions. What if there was a way to flip this model, so that patients control who sees their data while healthcare providers only access it with explicit permission?

The Problem with Today’s Medical Records

Data fragmentation – Records are scattered across clinics, labs, and hospitals.
Weak security – Centralized databases are lucrative targets for cyberattacks.
Lack of control – Patients rarely know who has accessed their data.
Interoperability gaps – Sharing across different institutions is messy and slow. These issues don’t just frustrate patients and hospitals/clinics, they create real risks in emergencies where fast and accurate access to medical records is critical.

This is where Codex storage comes in.

This article explores an innovative use case—leveraging Codex storage to securely manage medical records with patient-controlled access. It’s written to be clear and valuable for both technical and non-technical readers.

What is Codex Storage ?

Traditional systems are prone to a lot of privacy and security issues as stated above. Codex is a new way to store files securely using a network of computers around the world, not just one company’s servers. It’s like splitting a photo album into puzzle pieces, spreading them across many people’s computers, and the system is designed with ease of use and access, making sure you can always get it back, no matter what happens.

Codex is built to be:

Safe: Your data won’t disappear, even if some computers break or get attacked.
Private: No one can peek at your files or censor them.
Open: Anyone with a computer can help store data and join the network.
Cheap: It uses smart tricks to store data without needing tons of space.

How does this amazing technology work ?

Let's break that down step-by-step :

Breaking Files into Pieces (Erasure Coding): When you upload a file, Codex splits it into chunks, creates backup pieces using math, and distributes them across many computers worldwide. You only need a subset of those pieces to rebuild your file, making storage both reliable and cost-efficient.
Verifying Storage (Proof of Retrievability): Codex regularly checks that storage providers still hold your data by sending cryptographic “proofs” instead of the actual file. These proofs are logged on a blockchain, ensuring integrity without exposing your data.
Repairing Data (Lazy Repair): If some pieces go missing, Codex can recreate them from the remaining ones and redistribute them. This on-demand repair keeps data safe for years without wasting resources.
Incentives and Payments (CDX Token): Storage providers earn tokens (CDX) for keeping files safe. Payments are enforced by smart contracts, with penalties if providers lose data. This marketplace model keeps storage competitive, secure, and decentralized.
Peer-to-Peer Network : Codex runs on a global P2P network. Files are uploaded, stored, and retrieved directly between participants, without central control. This makes the system resistant to outages, censorship, and data silos.

In short, Codex splits, secures, verifies, repairs, and incentivizes storage, creating a system where data is always safe, private, and under your control. If you would like to go into more technical details, you can read more in the whitepaper and official docs.

So how can this be applied to healthcare data ?

Here's how such a system would work in practice

Patient-Controlled Access
Patients hold private keys to their records, granting or revoking access as needed. Smart contracts enforce time-bound or purpose-specific permissions.
End-to-End Encryption
Records are encrypted before storage, so only authorized parties can decrypt them. Even Codex node operators can’t view the data.
Interoperability & Accessibility
Decentralized storage enables global access and easy sharing across hospitals, clinics, or borders. Patients use a secure app to manage their records.
Immutable Audit Trail
All access is logged on the blockchain, creating a tamper-proof history that ensures transparency and regulatory compliance.
Cost-Effective & Scalable
Codex’s peer-to-peer model cuts centralized server costs while scaling to handle everything from simple records to large medical images

Benefits of This Approach:

Patient empowerment – Users truly own their medical history.
Improved security – Eliminates central databases as attack targets.
Better care – Fast, secure sharing means accurate diagnoses and fewer errors.
Compliance friendly – A patient-controlled model aligns with regulations like HIPAA and GDPR.

Imagine Alice(a patient), diagnosed with a chronic condition requiring care from multiple specialists. With Codex, Alice uploads her medical history—lab results, imaging, and prescriptions—to the platform, encrypted with her private key. She grants temporary access to her cardiologist for a consultation and later shares specific records with a research study, all without compromising her privacy. If Alice travels abroad, her records remain accessible to verified providers, ensuring continuity of care.

Hospitals benefit too. By leveraging Codex, they reduce infrastructure costs, mitigate data breach risks, and comply with regulations through immutable logs. Researchers can access anonymized datasets with patient consent, accelerating medical breakthroughs.

Challenges and Considerations

While promising, this use case requires addressing challenges:

User Education: Patients must understand key management to avoid losing access to their records.
Regulatory Compliance: Integration with existing healthcare regulations requires careful design.
Adoption: Healthcare providers must adopt Codex-compatible systems, necessitating industry collaboration.

Codex's decentralized storage opens the door to a future where patients are empowered to control their medical data, healthcare providers operate more efficiently, and trust in data security is paramount. By combining encryption, decentralization, and patient-centric design, Codex can redefine medical record management, making healthcare more secure, accessible, and equitable.

Where Is Codex Now? (As of August 2025)

Codex is still in testing, like a beta version of a game. Here’s the status:

Testnet: You can try it now, but it’s in “alpha” (early stage), so data might get erased during tests. They launched a version in 2024 where anyone can join, and a paid version (with CDX rewards) started in mid-2025.
Mainnet: The real, fully working version is planned for late 2025. It’ll have the core features (uploading, storing, fixing) first, with extras like encryption coming later.

Next Steps:

Start Here: Visit https://codex.storage and click “Join the Testnet.” Follow the guide to run a node or upload a file.
Ask Questions: Pop into the Codex Discord and say, “I’m new, how do I get started?” The community is friendly and will help

click here to subscribe to the Codex official newsletter.

Curiosity Note 😽: You can look at this project built by Guru using codex and also this article by Guru as well that explores other use cases.