How to Run and Test Your Midnight DApps

Giovanni — Tue, 23 Dec 2025 17:58:31 +0000

From DUST to tDUST: How to Run and Test Your Midnight DApps
Midnight’s decentralized application (DApp) platform introduces an elegant but straightforward token model — DUST fuels everything. Whether you’re deploying smart contracts or executing transactions, you’ll need a bit of DUST in your wallet to make things run.
But before you start thinking about tokenomics and gas fees, there’s good news: you don’t need real tokens to build and experiment. On the Midnight testnet, you’ll work with tDUST — a free, developer-friendly version of DUST designed for testing and learning.
Why You Need DUST
Every DApp interaction on the Midnight production network consumes DUST. This mechanism keeps the system efficient, secure, and fair. Developers who want to simulate that behavior locally can use tDUST on the testnet — the same way ETH and GoerliETH work on Ethereum networks.
How to Get Free tDUST
Here’s the quick start for developers setting up their Midnight testnet environment:
Set up your wallet.
Open your Lace wallet and copy your receiving address. Midnight uses the Bech32m format by default.
Check your address format.
While the testnet faucet currently supports both Bech32m and legacy HEX formats, the latter will be deprecated soon — so stick to Bech32m.
Visit the Midnight Faucet.
Go to the official Midnight Testnet Faucet. Paste your wallet address into the field.
Request test tokens.
Click “Request Tokens” and wait a few seconds. You should see a confirmation like this:
text
Transaction submitted. ID: 1644b988ac71dc6bd6...

You’ll instantly receive 1,000 tDUST in your wallet.
And that’s it — you’re now ready to deploy, test, and refine your Midnight DApps without spending a single real token.
Next Steps
Explore the Midnight docs for DApp deployment guides.
Join the Midnight developer community for updates and faucet availability.
When you’re ready, move from tDUST to real DUST on mainnet to go live.

Building a Midnight App with ViteJS

Giovanni — Wed, 17 Dec 2025 15:39:11 +0000

Midnight is a privacy‑first L1 where you write Compact smart contracts that compile to ZK circuits and then interact with them from a TypeScript app using generated artifacts and a local proof server. Below is a blog‑style tutorial showing how to scaffold a Midnight DApp frontend with Vite, connect it to a simple Compact contract, and get new users from zero to “first private tx” on Testnet‑02.

What is Midnight and why Vite

Midnight is a blockchain focused on selective disclosure: users can prove facts about their data (compliance, thresholds, membership) without revealing the underlying sensitive information. This is achieved via Compact, a domain‑specific language that compiles to zero‑knowledge circuits and enforces privacy by default.

For onboarding web developers, Vite offers a fast dev server, first‑class TypeScript support, and a familiar React/Vue/Svelte ecosystem, making it a natural fit for Midnight’s TypeScript‑first tooling and generated APIs.

Prerequisites and environment

Before writing any code, new users need both a Midnight wallet and a local dev setup. The basic checklist is:

Google Chrome for the Lace Midnight Preview wallet.
Node.js 20.x or higher (NVM is recommended for managing versions).
Docker Desktop for running the local proof server used to generate ZK proofs.
A code editor like VS Code, ideally with the Compact extension installed.

To get a wallet and test funds:

Install the Lace Midnight Preview Chrome extension from the Web Store and pin it.
Create a new wallet, set a strong password, and safely back up the seed phrase offline.
Copy your address and request tDUST from the official testnet faucet; the wallet should soon show a non‑zero tDUST balance.

Installing Compact and the proof server

Compact is the smart contract language for Midnight; you will compile .compact files into ZK circuits and TypeScript bindings. To install the CLI, run the official installer script:

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/midnightntwrk/compact/releases/download/compact-v0.2.0/compact-installer.sh \
  | sh

After installation, ensure the binary is on your PATH and verify it works:

compact --version   # prints Compact version
which compact       # prints installation path

Both commands should succeed to confirm your environment is ready to compile contracts.

For local proof generation, Midnight uses a proof server that runs inside Docker. Start it with:

docker run -p 6300:6300 midnightnetwork/proof-server -- \
  'midnight-proof-server --network testnet'

The container logs should indicate the server is listening on http://localhost:6300; in Lace’s settings under Midnight network, you can optionally point it to the local server (Local (http://localhost:6300)) so wallet‑side proofs also run against your machine.

Writing a minimal Compact contract

To keep the first tutorial approachable, define a simple “Hello Midnight” contract that stores a single string on‑chain. In a fresh folder (the contract side, separate from the Vite UI for clarity), create the required structure:

mkdir my-mn-app
cd my-mn-app
npm init -y

mkdir src contracts
touch contracts/hello-world.compact

At the top of hello-world.compact, pin the Compact language version to guard against breaking changes in future minor releases:

pragma language_version 0.17;

Next, define the ledger section, which declares the on‑chain state schema. Use Opaque<"string"> to store a variable‑length string while keeping it privacy‑aware:

export ledger message: Opaque<"string">;

Finally, add a circuit called storeMessage that accepts a private string input and writes it into the ledger, explicitly disclosing it so it becomes visible on the public state:

export circuit storeMessage(customMessage: Opaque<"string">): [] {
  message = disclose(customMessage);
}

Putting it all together, the full hello-world.compact file is:

pragma language_version 0.17;

export ledger message: Opaque<"string">;

export circuit storeMessage(customMessage: Opaque<"string">): [] {
  message = disclose(customMessage);
}

disclose is required because Compact treats user inputs as private by default; only explicitly disclosed values leak to the public ledger, embodying Midnight’s “privacy‑first” design.

Compiling to ZK circuits and artifacts

From the project root, compile the contract with Compact:

compact compile contracts/hello-world.compact contracts/managed/hello-world

This generates a contracts/managed/hello-world folder containing:

contract/ – compiled contract JSON artifacts for deployment and frontend integration.
keys/ – proving and verification keys used for generating and validating ZK proofs.
zkir/ – the Zero‑Knowledge Intermediate Representation bridging Compact to the ZK backend.
compiler/ – intermediate artifacts created during compilation.

These outputs are what your Vite app will ultimately use (directly or via Midnight’s SDK) to construct transactions, generate proofs via the proof server, and talk to the Midnight testnet.

Scaffolding a Vite + TypeScript frontend

With the contract compiled, you can now spin up a Vite app that will serve as the DApp’s UI layer. From a suitable directory (sibling to or inside your repo, depending on your preferred layout), run:

npm create vite@latest midnight-hello-vite -- --template react-ts
cd midnight-hello-vite
npm install

This creates a React + TypeScript project with a hot‑reloading dev server. For other ecosystems, you can swap react-ts for vue-ts, svelte-ts, or vanilla-ts while keeping the Midnight integration story the same.

To connect the Vite app to your contract artifacts, either copy the contracts/managed/hello-world folder into the frontend repo (for example under src/contracts) or expose it via a workspace/monorepo setup if you want a more production‑ready layout. The important part is that your UI code can import the compiled contract metadata and keys.

Wiring Midnight logic into the Vite app

At a high level, the Vite app will need to:

Detect and connect to the user’s Lace Midnight Preview wallet in Chrome.
Load the compiled contract JSON from contracts/managed/hello-world/contract.
Use the Midnight client APIs to create a transaction that calls storeMessage, feeding in the user’s string input.
Send the transaction to the testnet, letting the proof server handle ZK proof generation.

A tutorial‑friendly React flow in App.tsx might:

Render a “Connect Lace” button that triggers wallet API discovery in the browser.
Show an input field for the message and a “Store message” button.
On submit, construct a Midnight transaction invoking the storeMessage circuit, sign it via the wallet, and broadcast it.
Optionally query and display the latest message from the contract ledger to prove the write succeeded.

Although the exact JavaScript client bindings are documented elsewhere in the Midnight API reference, the key idea for onboarding is to present this as “just another TypeScript SDK” backed by artifacts generated from Compact, not a black‑box cryptography stack.

Onboarding tips for new Midnight users

To make the Vite tutorial an effective onboarding piece into the Midnight ecosystem, emphasize a few narrative points:

Midnight treats privacy as the default; disclosure is explicit, as seen in the disclose(customMessage) call.
The same tooling flow scales from a toy hello-world contract to real selective‑disclosure apps (compliance attestations, private credentials, etc.).
Lace + proof server + Compact + Vite is a complete vertical stack: wallet, proofs, contracts, and UI all working together on Testnet‑02.

Forem: Giovanni