So yesterday I talked about the Midnight City Simulation and Aliit Fellowship. Today I actually rolled up my sleeves and dove into the developer documentation .

Because let's be real – a blockchain is only as good as the tools it gives builders. And after spending hours reading through Midnight's technical docs, I found some fascinating details that most people aren't talking about.

Let me break down what I learned.

The Two-Token Model: NIGHT vs. DUST

Here's the first thing that surprised me: transactions on Midnight aren't paid with NIGHT .

They're paid with something called DUST – a separate resource token that serves a very specific purpose .

Think of it this way:

  • NIGHT is the "value token" – what you trade, stake, and hold

  • DUST is the "compute token" – what you spend to run transactions and smart contracts

But here's the clever part: holding NIGHT generates DUST . Your wallet automatically produces DUST over time based on how much NIGHT you hold .

This model means:

  1. Long-term holders benefit – More NIGHT = more transaction capacity

  2. Spam prevention – Every transaction costs something, even if it's tiny

  3. Separate concerns – Network compute isn't competing with speculation

Your wallet actually has three different addresses : one for shielded transactions (private), one for unshielded (public), and one specifically for DUST .

Midnight's three-wallet architecture: Wallet Facade coordinates Unshielded Wallet (NIGHT), Shielded Wallet (private transactions), and Dust Wallet (fees). Source: Midnight Developer Documentation

Wallet SDK 4.0.0 – Major Upgrade Just Dropped

This part is for the builders reading this.

Midnight released Wallet SDK 4.0.0 recently, and it's a significant upgrade . It's now considered production-ready and safe to deploy in public environments .

Key changes that matter:

Bech32m Addresses – This is the same format used by Cardano. It makes addresses human-readable and includes network identifiers, so you can't accidentally send testnet funds to mainnet . The legacy hex format is still supported but will be removed in future versions .

HD Wallet Support – There's now a dedicated package (@midnight-ntwrk/wallet-sdk-hd) that lets you deterministically derive different keys from a single seed . This is huge for wallet developers and exchanges .

Secret Keys Are Now Separate – Previously, secret keys were stored in the wallet state (security risk). Now they're completely separate – much safer .

Transaction Balancing Rewritten – The new balancer in TypeScript solves many previous issues . And if proving a transaction fails, the wallet now retries 3 times automatically before giving up .

Preview Network + midnight-js v3.0.0

For developers actually building dApps, the Preview Network is where you want to be right now .

Midnight released midnight-js v3.0.0 with some breaking changes, but also major improvements :

What's new:

  • Async transactions – submitTx now returns a Promise with the transaction ID

  • Better TypeScript support – Everything is properly typed

  • Storage encryption – AES-256-GCM for private state

  • Transaction TTL – You can set expiration times on transactions

The network endpoints have also been standardized :

text

RPC Node: rpc.preview.midnight.network
Indexer: indexer.preview.midnight.network/api/v3/graphql
Faucet: faucet.preview.midnight.network

And you can run the proof server locally with Docker:

bash

docker run -p 6300:6300 midnightnetwork/proof-server:6.1.0-alpha.6 \
-- midnight-proof-server --network preview

The Midday SDK – Community Tooling

Beyond the official tools, the community is already building. There's an SDK called @no-witness-labs/midday-sdk that simplifies dApp development even further .

It wraps the complexity and gives you a clean API:

javascript

import * as Midday from '@no-witness-labs/midday-sdk';

// Create client
const client = await Midday.Client.create();

// Load and deploy contract
const counter = await (await client.contractFrom('build/simple-counter')).deploy();

// Call actions
await counter.call('increment');

// Read state
const state = await counter.ledgerState();

This is exactly the kind of community tooling that shows real developer interest .

Why This Matters for Mainnet

Mainnet launches in ~2 weeks . Here's what the current state tells us:

  1. The economics are designed – The NIGHT/DUST model shows real thought about sustainable network economics

  2. Tooling is production-ready – Wallet SDK 4.0.0 is marked as stable and safe for production

  3. Multiple networks exist – Testnet-02, Preview, Devnet – developers have places to experiment

  4. Community is building – Third-party SDKs like Midday show genuine developer interest

The Midnight City Simulation is stress-testing the network . The Preview Network lets builders deploy real dApps . The Wallet SDK is production-ready .

Everything is lining up for that late March launch.

My Take

I'm not a developer, but I played one for this article. And here's what impressed me: the documentation is actually good .

Midnight's docs are clear, well-organized, and include working code examples . The release notes explain breaking changes and exactly how to migrate . The community SDKs are already emerging .

Compare this to other "privacy coins" that launch with barely any developer tools. Midnight is taking the opposite approach – build the tools first, then launch .

That's a bet on long-term adoption over short-term hype. And honestly? I respect it.

For developers reading this: the Preview Network is live, the faucet is working, and the tools are ready . If you want to build privacy-focused dApps before everyone else floods in, now's the time.

For everyone else: understanding the DUST model helps you see why holding NIGHT isn't just speculation – it's literally buying compute capacity on the network.

Mainnet in two weeks. The infrastructure is ready. Are you?

#night $NIGHT @MidnightNetwork