Your dApp is Public. Your Users are Not.

If you are building a game, a DAO, or a DeFi protocol on Monad, you have a problem: Total Transparency.

Players don't want their inventory value public.
DAO workers don't want their salaries public.
Traders don't want their alpha public.

Historically, adding privacy meant re-writing your entire stack in a ZK-rollup or learning Circom. Lambda changes this.

The Lambda SDK: Privacy as a Service

We built the Lambda SDK to be a "drop-in" privacy layer for Monad developers. You build on the high-performance EVM you love; we handle the cryptography.

Core Features

ZK-Gift Generation: Programmatically generate LambNotes (Red Packets) for user rewards.
Shielded Transfers: Allow users to move $LAMB privately within your app.
View Keys: Give users the power to "opt-in" to transparency for compliance or auditing.

Use Case: "Monad Quest" Loot Boxes

Imagine you are building an RPG on Monad.

The Old Way: A player kills a boss. The server sends 100 Gold. Everyone on-chain sees exactly who got rich.
The Lambda Way:
1. The Boss drops a ZK-Gift Link (a LambNote).
2. The player claims it off-chain or to a fresh address.
3. Result: The loot is secured, and the player's net worth remains a mystery.

Getting Started

import { createGiftNote, createClaimUrl } from '@lambda-protocol/sdk';
import { createWalletClient, custom, parseEther } from 'viem';
import { monad } from 'viem/chains';
 
// 0. Setup core constants
const LAMBDA_CONTRACT = "0x145A7b841E0944baEc1E8840FBa29FF08d1e7F79"; 
const depositAbi = [{
  name: 'deposit',
  type: 'function',
  inputs: [
    { name: 'commitment', type: 'uint256' },
    { name: 'amount', type: 'uint256' }
  ],
  stateMutability: 'payable', 
  outputs: [] 
}] as const;
 
// 1. Create a private gift (LambNote)
// This generates the zero-knowledge secrets locally (Off-chain)
const amount = parseEther("100");
const { note, commitmentHex } = await createGiftNote(amount);
 
// 2. Deposit into the Lambda Contract (On-chain)
// We send the "commitment" (public hash) and the funds. 
const wallet = createWalletClient({ chain: monad, transport: custom(window.ethereum) });
 
await wallet.writeContract({
  address: LAMBDA_CONTRACT,
  abi: depositAbi,
  functionName: 'deposit',
  args: [commitmentHex, amount],
  value: amount
});
 
// 3. Generate sharing link
const claimLink = createClaimUrl(note, "https://lambdamonad.xyz");
 
console.log(claimLink); // Send this to the user!

That's it. No ZK circuits to compile. You just use the trusted setup we already performed.

Security: The Trusted Setup

You might ask: "How do I know the cryptography is secure?"

Lambda relies on Groth16 proofs, which require a Trusted Setup Ceremony. This ceremony generates the cryptographic keys needed to create and verify proofs.

Why did we do it? If the setup is compromised, fake proofs could be generated (creating fake money).
How did we do it? We performed a multi-party computation (MPC) ceremony where "toxic waste" (randomness) was discarded forever.

You can verify our circuits and the ceremony artifacts in our open-source repository: Lambda-ZK on GitHub.

Ready to build? Check out our official documentation.

Next Up: The Whale's Vote - Why Governance Needs Privacy.