Building an unshielded token DApp with a working frontend.
📁 Full Source Code: midnight-apps/unshielded-token
We will keep it simple and use React VITE Ts as it is compatible with most of midnight packages, so the first thing we do is setup a basic wallet connection and for this we will also make sure to use the latest version of Dapp Connector V4
Be sure to have a package.json that's compatible
You can follow this official midnight network wallet connection guide on how to setup a basic wallet connection for reference check useWallet.ts how i handled the edge cases (I'll do a deep dive on wallet in a later post)
With the frontend ready to connect, i had some work to do on the contract side. Here are three core circuits i used to handle the native mint for the unshielded token vault lifecycle.
Natively Minting a Stablecoin into the vault with mintUnshieldedToken
We use a padded string for the domain to define the token standard in this case "stablecoin:usd"
export circuit mintToContract(amount: Uint<64>): Bytes<32> {
const domain = pad(32, "stablecoin:usd");
const color = mintUnshieldedToken(
disclose(domain),
disclose(amount),
left<ContractAddress, UserAddress>(kernel.self())
);
totalSupply = totalSupply + disclose(amount) as Uint<64>;
return color;
}
Note : We have to cast amount
Uint<64>when updating totalSupply
Transferring with sendUnshielded from vault
To move tokens, sendTouser requires us to reconstruct the color using the same domain and contract's address (kernel.self())
export circuit sendToUser(amount: Uint<64>, userAddr: UserAddress): [] {
const domain = pad(32, "stablecoin:usd");
const color = tokenType(disclose(domain), kernel.self());
sendUnshielded(
color,
disclose(amount) as Uint<128>,
right<ContractAddress, UserAddress>(disclose(userAddr))
);
}
Depositing into vault with receiveUnshielded
For receiveTokens circuit you need to be careful with bit sizes unlike the mint function receiveUnshielded strictly requires a Uint<128> for amount
export circuit receiveTokens(amount: Uint<128>): [] {
const domain = pad(32, "stablecoin:usd");
const color = tokenType(disclose(domain), kernel.self());
receiveUnshielded(color, disclose(amount));
}
See full contract code Contract.compact
Compiling the Contract
Now we will have to compile the contract so we can use its artifacts in the frontend [Verifier/Prover, ZKir..].
First install compact dev tools
curl --proto '=https' --tlsv1.2 -LsSf \
https://github.com/midnightntwrk/compact/releases/latest/download/compact-installer.sh | sh
Then compile
compact compile contracts/Contract.compact contracts/managed/stablecoin
Note : SKIP this step if you want to clone my repo because if you generate new keys you would need to redeploy again, as old keys in this path would no longer be usable for frontend unless you download them from github again (In case you wanted to use my contract) i have already deployed my own contract on Prepod network
db5d7cb3ed5ab23217abedb86831f6f5b23a9179e91e48dab88d819ef41b8e6d
If you do decide to recompile and redeploy run:
MNEMONIC="24 secret seed phrase from lace or 1am" npx tsx scripts/go.ts
Frontend Integration
So now we have a ready contract deployed on Prepod, the next steps is to integrate to the frontend and as you can see in the screenshot the features we want to cover are:
- Contract operations : Mint Tokens into vault, Send tokens from vault to an address, Deposit tokens into the vault.
- Statistics : Total Supply, Contract (Vault) Balance, Wallet Balance
- User Wallet : Basic OP such as doing basic transfer from your own wallet to another wallet and displaying your receiving address and balance.
1. Contract operations
Before we do anything, we need to make sure that Contract Providers are fully setup
privateStateProviderhaslevelPrivateStateProviderfor persistent localstorage
publicDataProviderUsed for onchain read state on the indexer
zkConfigProviderLoadsFetchZkConfigProvider<- Compiled Verifiers..
proofProviderresponsible for generating Zero-Knowledge proofs on your proof server
walletProviderhandlesbalanceTxviaconnectedApi.balanceUnsealedTransaction
midnightProviderSubmits tx viaconnectedApi.submitTransaction
Note : in this tutorial i rebuilt the providers in every function, in a production env initialize them once and reuse them across all operations.
The function below covers the full lifecycle minting into the vault contract, we can call await mintToContract(BigInt(amount)) in our UI to execute it.
export async function mintToContract(
connectedApi: ConnectedAPI,
coinPublicKey: string,
shieldedAddresses: { shieldedEncryptionPublicKey: string },
amount: bigint,
onSuccess: (txId: string) => void,
onError: (err: string) => void
): Promise<void> {
try {
console.log('[Mint] === Starting mintToContract ===');
console.log('[Mint] Amount:', amount.toString());
console.log('[Mint] Contract:', CONTRACT_ADDRESS);
const mods = await getModules();
const { indexerModule, FetchZkConfigProvider, levelModule, CompiledContract, ledger, proofModule } = mods;
const indexerPublicDataProvider = indexerModule.indexerPublicDataProvider;
const levelPrivateStateProvider = levelModule.levelPrivateStateProvider;
const zkConfigProvider = new FetchZkConfigProvider(window.location.origin + CONTRACT_PATH, fetch.bind(window));
const proofProvider = proofModule.httpClientProofProvider(PROOF_SERVER, zkConfigProvider);
const providers: any = {
privateStateProvider: levelPrivateStateProvider({
midnightDbName: 'midnight-stablecoin-db',
privateStateStoreName: STORE_NAME,
accountId: coinPublicKey,
privateStoragePasswordProvider: () => STORAGE_PASSWORD,
}),
publicDataProvider: indexerPublicDataProvider(INDEXER_HTTP, INDEXER_WS),
zkConfigProvider,
proofProvider,
walletProvider: {
getCoinPublicKey: () => coinPublicKey,
getEncryptionPublicKey: () => shieldedAddresses.shieldedEncryptionPublicKey,
async balanceTx(tx: any) {
const serialized = uint8ArrayToHex(tx.serialize());
const result = await connectedApi.balanceUnsealedTransaction(serialized);
const bytes = hexToUint8Array(result.tx);
return ledger.Transaction.deserialize('signature', 'proof', 'binding', bytes);
},
},
midnightProvider: {
submitTx: async (tx: any): Promise<string> => {
const serialized = uint8ArrayToHex(tx.serialize());
console.log('[Mint] Calling submitTransaction, hex length:', serialized.length);
await connectedApi.submitTransaction(serialized);
return tx.identifiers()[0];
},
},
};
const [{ findDeployedContract }] = await Promise.all([
import('@midnight-ntwrk/midnight-js-contracts'),
]);
const contractModule = await import(CONTRACT_PATH + '/contract/index.js');
const compiledContract = CompiledContract.make('stablecoin', contractModule.Contract).pipe(
CompiledContract.withVacantWitnesses,
CompiledContract.withCompiledFileAssets(CONTRACT_PATH)
);
const contract: any = await findDeployedContract(providers, {
contractAddress: CONTRACT_ADDRESS,
compiledContract,
privateStateId: 'stablecoinState',
initialPrivateState: {},
});
const currentState = contract?.state?.();
console.log('[Mint] Current contract state ledger:', JSON.stringify(currentState?.ledger, null, 2));
console.log('[Mint] Calling contract.callTx.mintToContract...');
const txData = await contract.callTx.mintToContract(amount);
console.log('[Mint] SUCCESS, txId:', txData.public.txId);
console.log('[Mint] Color returned:', txData.private.result);
onSuccess(txData.public.txId);
} catch (err) {
console.error('[Mint] Error:', err);
onError(err instanceof Error ? err.message : String(err));
}
}
When you call
const txData = await contract.callTx.mintToContract(amount);
Each key on callTx corresponds to an exported circuit in our compact circuit which in this case is
export circuit mintToContract(amount: Uint<64>): Bytes<32>
Which uses mintUnshieldedToken called from the inside
Note : The proof generation might take some time before popup appears, in my case im using local proof server at port 6300 so it's fast.
So now we've successfully minted some tokens into our vault contract, we now need to send the tokens from the vault into our own address.
First things first, we must handle how user addresses are encoded so we created a helper function for this it parses Bech32m string and decodes to unshielded address and then returns Raw Bytes because sendTouser circuit expects Bytes<32> field
export async function encodeUserAddress(bech32Address: string): Promise<Uint8Array> {
const mods = await getModules();
const { addressModule } = mods;
const { MidnightBech32m, UnshieldedAddress } = addressModule;
try {
const parsed = MidnightBech32m.parse(bech32Address);
const decoded: any = parsed.decode(UnshieldedAddress, 'preprod');
return decoded.data;
} catch (e) {
console.error('[encodeUserAddress] Error:', e);
throw new Error('Invalid address format');
}
}
Now this function takes user input and runs it through our helper function encodeUserAddress(recipient) and most importantly calls await store.contractSend(params..) calls our circuit sendToUser which has sendUnshielded inside.
const handleSend = async () => {
if (!amount || !recipient || !connectedApi) return;
const recipientBytes = await encodeUserAddress(recipient);
const store = useWalletStore.getState();
const shieldedAddresses = await connectedApi.getShieldedAddresses();
const coinPublicKey = shieldedAddresses.shieldedCoinPublicKey;
await store.contractSend(
connectedApi,
coinPublicKey,
shieldedAddresses,
BigInt(amount),
recipientBytes,
(txId: string) => {
useWalletStore.getState().setTransactionHash(txId);
useWalletStore.getState().loadWalletState();
},
(errMsg: string) => {
useWalletStore.getState().setError(errMsg);
}
);
};
Now we can try to deposit Our stablecoin token into the vault using receiveUnshielded.
In our frontend we have handleReceive, it functions in a similar way to handleSend .. store.receiveTokens(params..) calls our exported circuit receiveTokens(amount: Uint<128>) which has receiveUnshielded(color, disclose(amount)) inside
const handleReceive = async () => {
if (!amount || !connectedApi) return;
const store = useWalletStore.getState();
const shieldedAddresses = await connectedApi.getShieldedAddresses();
const coinPublicKey = shieldedAddresses.shieldedCoinPublicKey;
await store.receiveTokens(
connectedApi,
coinPublicKey,
shieldedAddresses,
BigInt(amount),
(txId: string) => {
useWalletStore.getState().setTransactionHash(txId);
useWalletStore.getState().loadWalletState();
},
(errMsg: string) => {
useWalletStore.getState().setError(errMsg);
}
);
};
Note : I know you are seeing me use
getShieldedAddresses()Let me explain why. It is the most convenient way to retrieve both keys in one call as it returns shieldedAddress, shieldedCoinPublicKey, and shieldedEncryptionPublicKey.
2. Statistics
The vault contract has a state called Balance, it returns a set of Tokens Balances and what we did here was to iterate through balances array to find how many tokens with our token ID <-- For a token ID to appear you need to execute a mint operation.
export async function getContractBalance(): Promise<bigint> {
try {
const mods = await getModules();
const { indexerModule } = mods;
const indexerPublicDataProvider = indexerModule.indexerPublicDataProvider;
const provider = indexerPublicDataProvider(INDEXER_HTTP, INDEXER_WS);
const contractState = await provider.queryContractState(CONTRACT_ADDRESS);
console.log('[getContractBalance] Contract state balance:', contractState?.balance);
if (!contractState?.balance) return 0n;
for (const [key, value] of contractState.balance.entries()) {
console.log('[getContractBalance] Key:', key, 'Value:', value.toString());
if (key && typeof key === 'object' && 'raw' in key && key.raw === STABLECOIN_TOKEN) {
console.log('[getContractBalance] Found balance:', value.toString());
return value;
}
}
return 0n;
} catch (err) {
console.error('[getContractBalance] Error:', err);
return 0n;
}
}
Now we need to get User's stablecoin balance, we first get connectedApi.getUnshieldedBalances() to get all user wallet balances and then filter the results with balances[STABLECOIN_TOKEN]
export async function getUserStablecoinBalance(connectedApi: ConnectedAPI): Promise<bigint> {
try {
const balances = await connectedApi.getUnshieldedBalances();
const stablecoinBalance = balances[STABLECOIN_TOKEN];
return stablecoinBalance || 0n;
} catch (err) {
console.error('[getUserStablecoinBalance] Error:', err);
return 0n;
}
}
In order to retrieve totalSupply we created a function getContractState() it runs through provider.queryContractState(CONTRACT_ADDRESS); to return the data we need such as totalSupply.
export async function getContractState(): Promise<ContractState> {
try {
const mods = await getModules();
const { indexerModule } = mods;
const indexerPublicDataProvider = indexerModule.indexerPublicDataProvider;
const provider = indexerPublicDataProvider(INDEXER_HTTP, INDEXER_WS);
const contractState = await provider.queryContractState(CONTRACT_ADDRESS);
if (!contractState) {
console.log('[ContractState] No contract state found');
return { totalSupply: 0n, totalBurned: 0n };
}
const contractModule = await import(CONTRACT_PATH + '/contract/index.js');
const ledgerState = contractModule.ledger(contractState.data);
console.log('[ContractState] Ledger totalSupply:', ledgerState.totalSupply.toString());
console.log('[ContractState] Ledger totalBurned:', ledgerState.totalBurned.toString());
return {
totalSupply: ledgerState.totalSupply,
totalBurned: ledgerState.totalBurned,
};
} catch (err) {
console.error('[ContractState] Error:', err);
console.error('[ContractState] Error message:', err instanceof Error ? err.message : String(err));
console.error('[ContractState] Error stack:', err instanceof Error ? err.stack : '');
return { totalSupply: 0n, totalBurned: 0n };
}
}
3. Wallet operations
For displaying user receiving addresses and Stablecoin balance (Read Section 2 for in depth details on how to get user Stablecoin balance)
const unshieldedAddress = await connectedApi.getUnshieldedAddress();
const unshieldedBalances = await connectedApi.getUnshieldedBalances();
import { useState, useEffect } from 'react';
import { Link } from 'react-router-dom';
import { useWalletStore } from '../hooks/useWallet';
import { getUserStablecoinBalance } from '../hooks/wallet/services/contractCalls';
export function WalletInfoPage() {
const { connectedApi, addresses } = useWalletStore();
const [balance, setBalance] = useState<bigint | null>(null);
const [copied, setCopied] = useState<string | null>(null);
useEffect(() => {
if (!connectedApi) return;
const fetchBalance = async () => {
const bal = await getUserStablecoinBalance(connectedApi);
setBalance(bal);
};
fetchBalance();
const interval = setInterval(fetchBalance, 15000);
return () => clearInterval(interval);
}, [connectedApi]);
const handleCopy = async (text: string, field: string) => {
await navigator.clipboard.writeText(text);
setCopied(field);
setTimeout(() => setCopied(null), 2000);
};
const formatBalance = (bal: bigint | null): string => {
if (bal === null) return '—';
return bal.toLocaleString();
};
const formatAddress = (addr: string): string => {
if (!addr) return '—';
return addr.length > 24 ? `${addr.slice(0, 12)}...${addr.slice(-12)}` : addr;
};
Now we move to sending the stablecoin token between user wallets, handlesend (different from contractSend one) looks like
const handleSend = async () => {
if (!amount || !recipient) return;
await sendStablecoin(recipient, BigInt(amount));
};
This is much simpler than contract operations because sendStablecoin is available at the wallet level not a circuit call, it uses Dapp Connector V4 API to initiate the transfer and prompt the user.
await makeTransfer(
connectedApi,
recipient,
amount,
async () => {
setTransactionHash('transfer-success');
await loadWalletState();
},
(err) => {
if (err === 'Disconnected') {
useWalletStore.getState().resetConnection();
setError('Wallet disconnected. Please reconnect.');
} else {
setError(err);
}
}
);
Key differences from contractSend
contractSend | makeTransfer | |
|---|---|---|
| Funds source | Vault funds | User funds |
| Mechanism | handleSend | Dapp Connector makeTransfer |
| Address Encode | Requires encoding -> Bytes<32> | Passes Bech32m directly |
| Zk Proofs | Required for circuit execution | Handled by Wallet |
When to use unshielded vs shielded tokens and the privacy tradeoffs
| Unshielded | Shielded | |
|---|---|---|
| Privacy Mechanism | None, completely transparent blockchain transactions | Zero-Knowledge proofs (Zswap) |
| Legal Compliance | Can be audited for AML | Requires keys for selective disclosure |
| Use cases | Compliant Stablecoins.. as required by regulators | Confidential transfers.. |
Why did I choose UnShielded for my Stablecoin?
Regulatory Compliance : Stablecoin issuers typically need to demonstrate full traceability of supply and transfers due to AML (Anti-money laundering) Regulations.
Verifiability : Vault demonstrate a native mint functionality of this Stablecoin and it contains a public state
totalSupplythats publicly readable in which regulators can monitor.Exchange Listings : Many exchanges like Binance.. have decided to delist XMR for this reason, Regulators put legal pressure on Binance to force a delist while tokens like NIGHT did manage to get listed because it is Unshielded precisely
When would i choose Shielded over UnShielded?
Private tokenized securities : where transfers are confidential While specific properties like voting rights remain verifiable.
Regulated industries requiring data minimization : in healthcare industries, frameworks like GDPR, CCPA, and HIPAA requires minimal data disclosure and shielded tokens ensure sensitive information stays in local storage while Zero-knowledge proofs can still confirm eligibility and compliance.
forward secrecy : Even if encryptions keys are compromised in the future, shielded transactions remains private and this is something unshielded transactions cannot offer.
The bottom line : Midnight is multi-modal it does not enforce anything like XMR enforces privacy and BTC enforces transparency. It is permissionless, You can use whatever works for your project.