🎉 LIVE ON ARBITRUM SEPOLIA!
Solidity Contract:0xf935f364f797AF2336FfDb3ee06431e1616B7c6C
Stylus Contract (Rust):0x531668485fe72c14bb3eed355916f27f4d0b7dea
Privacy-preserving access control using Zero-Knowledge Proofs and cryptographic tokens on Arbitrum.
- 🔗 Solidity Contract on Arbiscan
- 🦀 Stylus (Rust) Contract on Arbiscan
- ✅ Sourcify Verification
- 📊 Deployment Summary
- 🎫 Development Tasks
ZKPJWT is a decentralized protocol for access control to encrypted data using Zero-Knowledge Proofs and Merkle trees. It allows you to prove you're authorized to access data without revealing your specific identity.
- 🔒 Privacy-Preserving: Prove membership without revealing identity
- 🌳 Merkle Tree Proofs: Efficient cryptographic verification
- 🔐 AES-256-GCM Encryption: Military-grade encryption
- ⛓️ On-Chain Verification: Decentralized proof verification
- 📦 Easy Integration: Simple NPM library
┌─────────────┐
│ Sender │ → Create authorized group
│ │ → Encrypt message
└──────┬──────┘
│
▼
┌─────────────────────┐
│ Merkle Tree │ → Build tree from wallets
│ [wallet1...] │ → Get Merkle root (R)
└──────┬──────────────┘
│
▼
┌─────────────────────┐
│ ZKPJWT Token │ → {encrypted, root, key}
└──────┬──────────────┘
│
▼
┌─────────────┐
│ Receiver │ → Generate Merkle proof
│ │ → Verify on-chain
│ │ → Decrypt if authorized
└─────────────┘
When a receiver wants to decrypt a ZKPJWT token, the following cryptographic process occurs:
// 1. Parse the ZKPJWT token (JSON structure)
const token = JSON.parse(zkpjwtString);
// Token contains:
// {
// version: "1.0.0",
// algorithm: "ZKPJWT-MERKLE-AES256",
// encrypted: "base64EncodedCiphertext",
// merkleRoot: "0x7f8a...",
// authorizedWallets: ["0x123...", "0x456..."],
// sender: "0xabc...",
// timestamp: 1699999999999
// }// 2. Check if receiver's wallet is in authorized list (O(n) search)
const isInList = token.authorizedWallets.some(
wallet => wallet.toLowerCase() === receiverAddress.toLowerCase()
);
if (!isInList) {
// ❌ Early exit - receiver not authorized
throw new Error("Access denied: wallet not in authorized group");
}// 3. Build Merkle leaf from receiver's address
const leaf = keccak256(toUtf8Bytes(receiverAddress.toLowerCase()));
// leaf = keccak256("0x742d35cc6634c0532925a3b844bc9e7595f0beb")
// = 0x9f2d4e7a3c1b8e6f...
// 4. Generate Merkle proof (array of sibling hashes)
const proof = generateMerkleProof(receiverAddress, token.authorizedWallets);
// proof = [
// "0x1a2b3c...", // sibling at level 0
// "0x4d5e6f...", // sibling at level 1
// "0x7g8h9i..." // sibling at level 2
// ]
// 5. Call smart contract on Arbitrum
const contract = new Contract(CONTRACT_ADDRESS, ABI, signer);
const tx = await contract.unlockAccess(
token.merkleRoot, // Published root on-chain
leaf, // keccak256(receiverAddress)
proof // Array of sibling hashes
);
// 6. Wait for transaction confirmation
const receipt = await tx.wait();
// 7. Check for AccessGranted event
const isGranted = receipt.logs.some(log =>
contract.interface.parseLog(log)?.name === 'AccessGranted'
);🔐 Merkle Proof Verification (Inside Smart Contract)
// Contract verifies proof by reconstructing root:
function verifyProof(
bytes32 root,
bytes32 leaf,
bytes32[] memory proof
) public pure returns (bool) {
bytes32 computedHash = leaf;
// Traverse proof array, hashing with siblings
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
// Sort before hashing (maintains tree structure)
if (computedHash <= proofElement) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
// Final hash should equal published root
return computedHash == root;
}// 8. If on-chain verification passes, decrypt message
if (isGranted) {
// Extract encryption key from token (in production, use KDF)
const encryptionKey = Buffer.from(token.keyInfo.key, 'hex');
const iv = Buffer.from(token.keyInfo.iv, 'hex');
// 9. Base64 decode the ciphertext
const ciphertext = Buffer.from(token.encrypted, 'base64');
// 10. Initialize AES-256-GCM decipher
const decipher = crypto.createDecipheriv('aes-256-gcm', encryptionKey, iv);
// 11. Extract authentication tag (last 16 bytes)
const authTag = ciphertext.slice(-16);
const encryptedData = ciphertext.slice(0, -16);
decipher.setAuthTag(authTag);
// 12. Decrypt and verify integrity
let decrypted = decipher.update(encryptedData, null, 'utf8');
decrypted += decipher.final('utf8');
// ✅ Message successfully decrypted!
console.log("Decrypted message:", decrypted);
}| Component | Algorithm | Purpose |
|---|---|---|
| Hashing | keccak256 |
Create Merkle tree leaves and nodes |
| Merkle Tree | Binary tree with keccak256 | Prove membership in O(log n) proof size |
| Encryption | AES-256-GCM |
Encrypt message with authenticated encryption |
| Encoding | Base64 |
Encode binary ciphertext for JSON transport |
| Smart Contract | Solidity |
Verify proofs on-chain (Arbitrum L2) |
- Proof Size:
O(log n)where n = number of authorized wallets - Verification Time:
O(log n)on-chain hash operations - Gas Cost: ~50,000 gas for proof verification (cheap on Arbitrum!)
- Encryption: Constant time
O(1)for AES-256-GCM - Security: 256-bit security level (quantum-resistant roadmap)
- Confidentiality: AES-256-GCM encryption (NIST approved)
- Authentication: GCM mode provides authenticity tag
- Zero-Knowledge: Merkle proof reveals only membership, not position
- Immutability: Root published on Arbitrum blockchain
- Non-repudiation: All access attempts logged on-chain
{
"version": "1.0.0",
"algorithm": "ZKPJWT-MERKLE-AES256",
"encrypted": "U2FsdGVkX1+vupppZksvRf5pq5g5XjFRlipRkwB0K1Y=",
"merkleRoot": "0x7f8a3c2b9e1d4f6a8c5b2e9d1f3a6c8b5e2d9f1a3c6b8e5d2f9a1c3b6e8d5f2a9",
"authorizedWallets": [
"0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
"0x1234567890123456789012345678901234567890",
"0xabcdef1234567890abcdef1234567890abcdef12",
"0x9876543210fedcba9876543210fedcba98765432"
],
"sender": "0xSenderWalletAddress...",
"timestamp": 1731456789000,
"keyInfo": {
"key": "a3f5c8d2e9b1f4a6c8e5b2d9f1a3c6b8e5d2f9a1c3b6e8d5f2a9c1b3e6f8d5a2",
"iv": "1a2b3c4d5e6f7a8b9c0d1e2f"
}
}Example: 4 authorized wallets
Wallets:
W0 = 0x742d35Cc...
W1 = 0x12345678...
W2 = 0xabcdef12...
W3 = 0x98765432...
Step 1: Hash each wallet (Leaves)
L0 = keccak256(W0) = 0x9f2d4e7a...
L1 = keccak256(W1) = 0x3c1b8e6f...
L2 = keccak256(W2) = 0x7a5d9c2b...
L3 = keccak256(W3) = 0x4e8f1a6c...
Step 2: Build tree bottom-up
Level 1 (Parent nodes):
N0 = keccak256(L0 + L1) = 0x2b4d6e8f...
N1 = keccak256(L2 + L3) = 0x9a1c3e5d...
Level 2 (Root):
ROOT = keccak256(N0 + N1) = 0x7f8a3c2b... ← Published on-chain
Merkle Tree Structure:
ROOT
/ \
N0 N1
/ \ / \
L0 L1 L2 L3
| | | |
W0 W1 W2 W3
Receiver = W0 (0x742d35Cc...)
Proof needed to verify W0 is in tree:
proof = [L1, N1] ← Only 2 hashes for 4 wallets!
Verification steps:
1. Compute: hash1 = keccak256(L0 + L1) [using proof[0]]
→ Should equal N0
2. Compute: hash2 = keccak256(hash1 + N1) [using proof[1]]
→ Should equal ROOT
3. Compare: hash2 == ROOT (stored on-chain)
✅ If match → W0 is authorized!
❌ If no match → W0 is NOT authorized
Gas cost: Only 2 keccak256 operations on-chain!
| Approach | Privacy | Gas Cost | Scalability | On-Chain Data |
|---|---|---|---|---|
| Store all wallets on-chain | ❌ No privacy | 💰💰💰 High | ❌ O(n) storage | 📦 Full list |
| Centralized server | ❌ No decentralization | 💰 Free | ✅ Unlimited | 📦 None |
| ZKPJWT (Merkle) | ✅ Zero-knowledge | 💰 Low | ✅ O(log n) | 📦 32 bytes (root) |
Example: 1,000 authorized wallets
- Traditional: Store 1,000 addresses = ~2,000,000 gas = ~$50
- ZKPJWT: Store 1 root (32 bytes) = ~20,000 gas = ~$0.50
- Proof size: 10 hashes (log₂ 1000 ≈ 10)
- Verification: 10 keccak operations = ~6,000 gas
┌────────┐ ┌──────────┐ ┌────────────┐ ┌──────────┐
│ Sender │ │ Library │ │ Contract │ │ Receiver │
└───┬────┘ └────┬─────┘ └─────┬──────┘ └────┬─────┘
│ │ │ │
│ 1. Select recipients │ │ │
├───────────────────────>│ │ │
│ [0x123..., 0x456...] │ │ │
│ │ │ │
│ 2. Build Merkle tree │ │ │
│<───────────────────────┤ │ │
│ root: 0x7f8a... │ │ │
│ │ │ │
│ 3. Encrypt message │ │ │
├───────────────────────>│ │ │
│ "Secret data" │ │ │
│<───────────────────────┤ │ │
│ encrypted: "U2Fsd..." │ │ │
│ │ │ │
│ 4. Publish root │ │ │
├────────────────────────┼─────────────────────────>│ │
│ publishRoot(root) │ │ │
│ │ │ │
│ │ 5. Store root │ │
│ │ emit RootPublished │ │
│<───────────────────────┼──────────────────────────┤ │
│ tx: 0xabc... │ │ │
│ │ │ │
│ 6. Generate ZKPJWT │ │ │
├───────────────────────>│ │ │
│<───────────────────────┤ │ │
│ token: {...} │ │ │
│ │ │ │
│ 7. Share token (off-chain) │ │
├────────────────────────┼──────────────────────────┼─────────────────────────>│
│ via: QR, clipboard, │ │ │
│ email, IPFS, etc. │ │ │
│ │ │ │
│ │ │ 8. Parse token │
│ │ │<─────────────────────────┤
│ │ │ │
│ │ │ 9. Check if in list │
│ │ │ (local validation) │
│ │ │<─────────────────────────┤
│ │ │ │
│ │ │ 10. Generate proof │
│ │<─────────────────────────┼──────────────────────────┤
│ │ leaf, proof │ │
│ │ │ │
│ │ 11. Verify on-chain │ │
│ │ unlockAccess(...) │<─────────────────────────┤
│ │──────────────────────────>│ │
│ │ │ │
│ │ 12. Verify proof │ │
│ │ computeHash == root? │ │
│ │ │ │
│ │ 13. Grant access │ │
│ │ emit AccessGranted │ │
│ │<──────────────────────────┤ │
│ │ │ │
│ │ 14. Return success │ │
│ │──────────────────────────┼─────────────────────────>│
│ │ │ │
│ │ │ 15. Decrypt message │
│ │<─────────────────────────┼──────────────────────────┤
│ │ key, iv, ciphertext │ │
│ │ │ │
│ │ 16. AES-256-GCM │ │
│ │ decipher.final() │ │
│ │──────────────────────────┼─────────────────────────>│
│ │ │ plaintext: "Secret..." │
│ │ │ │
SENDER SIDE (Steps 1-7)
// Step 1: Define authorized group
const authorizedWallets = [
'0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
'0x1234567890123456789012345678901234567890'
];
// Step 2: Build Merkle tree
const tree = createMerkleTree(authorizedWallets);
const root = tree.getRoot();
// Step 3: Encrypt message with AES-256-GCM
const secretMessage = "Confidential project details";
const key = crypto.randomBytes(32); // 256-bit key
const iv = crypto.randomBytes(12); // 96-bit IV
const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
let encrypted = cipher.update(secretMessage, 'utf8', 'base64');
encrypted += cipher.final('base64');
const authTag = cipher.getAuthTag();
// Step 4: Publish root on Arbitrum
const contract = new Contract(CONTRACT_ADDRESS, ABI, signer);
const tx = await contract.publishRoot(root);
await tx.wait();
// Step 5: Generate ZKPJWT token
const zkpjwt = {
version: '1.0.0',
algorithm: 'ZKPJWT-MERKLE-AES256',
encrypted: encrypted + authTag.toString('base64'),
merkleRoot: root.toString('hex'),
authorizedWallets: authorizedWallets,
sender: await signer.getAddress(),
timestamp: Date.now(),
keyInfo: {
key: key.toString('hex'),
iv: iv.toString('hex')
}
};
// Step 6: Share token (QR code, clipboard, etc.)
const tokenString = JSON.stringify(zkpjwt);
await navigator.clipboard.writeText(tokenString);RECEIVER SIDE (Steps 8-16)
// Step 8: Parse received token
const token = JSON.parse(receivedTokenString);
// Step 9: Local check - am I in the list?
const myAddress = await signer.getAddress();
const isInList = token.authorizedWallets.some(
w => w.toLowerCase() === myAddress.toLowerCase()
);
if (!isInList) {
throw new Error('Not authorized');
}
// Step 10: Generate Merkle proof
const tree = createMerkleTree(token.authorizedWallets);
const leaf = keccak256(toUtf8Bytes(myAddress.toLowerCase()));
const proof = tree.getProof(leaf);
// Step 11: Verify on-chain
const contract = new Contract(CONTRACT_ADDRESS, ABI, signer);
const tx = await contract.unlockAccess(
token.merkleRoot,
leaf,
proof.map(p => p.data)
);
// Step 12-13: Wait for confirmation
const receipt = await tx.wait();
// Check for AccessGranted event
const accessGranted = receipt.logs.some(log => {
const parsed = contract.interface.parseLog(log);
return parsed?.name === 'AccessGranted';
});
if (!accessGranted) {
throw new Error('Access denied by contract');
}
// Step 14-16: Decrypt message
const encryptionKey = Buffer.from(token.keyInfo.key, 'hex');
const iv = Buffer.from(token.keyInfo.iv, 'hex');
const ciphertext = Buffer.from(token.encrypted, 'base64');
const authTag = ciphertext.slice(-16);
const encryptedData = ciphertext.slice(0, -16);
const decipher = crypto.createDecipheriv('aes-256-gcm', encryptionKey, iv);
decipher.setAuthTag(authTag);
let decrypted = decipher.update(encryptedData, null, 'utf8');
decrypted += decipher.final('utf8');
console.log('✅ Decrypted:', decrypted);
// Output: "Confidential project details"npm install zkpjwtimport {
createMerkleTree,
encryptMessage,
generateZKPJWT,
verifyMembership,
decryptMessage
} from 'zkpjwt';
// 1. Sender: Create authorized group
const authorizedWallets = [
'0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
'0x1234567890123456789012345678901234567890'
];
const merkleTree = createMerkleTree(authorizedWallets);
const merkleRoot = merkleTree.getRoot().toString('hex');
// 2. Encrypt message
const { encrypted, key, iv } = encryptMessage("Secret message!");
// 3. Generate ZKPJWT token
const zkpjwt = generateZKPJWT({
encrypted,
merkleRoot,
keyInfo: { key: key.toString('hex'), iv: iv.toString('hex') }
});
// 4. Receiver: Verify and decrypt
const isAuthorized = verifyMembership(receiverWallet, merkleTree);
if (isAuthorized) {
const decrypted = decryptMessage(encrypted, key, iv);
console.log('✅ Message:', decrypted);
}zkp-jwt-library/
├── library/ # NPM package (TypeScript)
│ ├── src/
│ │ ├── index.ts # Core functions
│ │ └── examples.ts
│ └── package.json
│
├── circuits/ # Zero-Knowledge circuits (Circom)
│ └── merkleProof.circom
│
├── contracts/ # Smart contracts
│ └── ZKPJWTVerifier.sol # Solidity verifier
│
├── demo/ # React demo app
│ └── src/
│ ├── components/
│ │ ├── SenderPanel.tsx
│ │ └── ReceiverPanel.tsx
│ └── App.tsx
│
└── README.md
cd library
npm install
npm run buildcd demo
npm install
npm run devRequirements:
- MetaMask installed
- Arbitrum Sepolia network configured
- Testnet ETH for gas fees
Already deployed! Contract address: 0xf935f364f797AF2336FfDb3ee06431e1616B7c6C
To interact with the deployed contract:
import { ethers } from 'ethers';
import { CONTRACT_ADDRESS, CONTRACT_ABI } from './demo/src/config';
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, signer);
// Publish Merkle root
await contract.publishRoot(merkleRoot);
// Verify proof
const isValid = await contract.verifyProof(root, leaf, proof);cd library
npm run build
node dist/examples.jsExperience ZKPJWT in action:
- Connect MetaMask to Arbitrum Sepolia
- Sender Panel: Create encrypted message and authorized wallet list
- Receiver Panel: Verify membership and decrypt
🌐 Live Demo (Coming soon)
Encrypted messages that only authorized group members can read.
const groupMembers = ['0xAlice...', '0xBob...', '0xCarol...'];
const tree = createMerkleTree(groupMembers);
const { encrypted, key, iv } = encryptMessage("Group meeting at 3pm");Prove token ownership without revealing balance.
// Only NFT holders can access
const nftHolders = await getNFTHolders(contractAddress);
const token = generateZKPJWT({ encrypted, merkleRoot, keyInfo });Prove qualifications without exposing data.
// Prove you have a diploma without showing it
const graduates = ['0xGrad1...', '0xGrad2...'];
const proof = generateProof(myWallet, createMerkleTree(graduates));| Component | Technology |
|---|---|
| Blockchain | Arbitrum Sepolia |
| Smart Contracts | Solidity / Rust (Stylus) |
| ZK Circuits | Circom + SnarkJS |
| Library | TypeScript + Node.js |
| Frontend | React + Vite + ethers.js |
| Encryption | AES-256-GCM |
| Hashing | Keccak256 |
function verifyProof(
bytes32 root,
bytes32 leaf,
bytes32[] calldata proof
) public pure returns (bool)
function unlockAccess(
bytes32 root,
bytes32 leaf,
bytes32[] calldata proof
) external returns (bool)- Network: Arbitrum Sepolia (Chain ID: 421614)
- Address:
0xf935f364f797AF2336FfDb3ee06431e1616B7c6C - Explorer: View on Arbiscan
- Verification: Sourcify
- Network: Arbitrum Sepolia (Chain ID: 421614)
- Address:
0x531668485fe72c14bb3eed355916f27f4d0b7dea - Explorer: View on Arbiscan
- Contract Size: 11.2 KiB (WASM: 36.6 KiB)
- Deployment Gas: 0.000088 ETH
- Status: ✅ Cached in ArbOS for optimized calls
| Operation | Solidity Gas | Stylus Gas (Est.) | Savings |
|---|---|---|---|
| Publish Root | ~45,000 | ~4,500 | 90% |
| Verify Proof | ~25,000/level | ~2,500/level | 90% |
| Unlock Access | ~70,000 | ~7,000 | 90% |
| Total (typical flow) | ~140,000 | ~14,000 | ~10x faster |
🦀 Stylus Benefits: The Rust implementation leverages Arbitrum Stylus for ~10x gas reduction while maintaining identical functionality and security guarantees.
# Unit tests
cd library
npm test
# Integration tests
cd contracts
npx hardhat test
# E2E tests
cd demo
npm run test:e2eA: The encryption key IS shared in the ZKPJWT token (in keyInfo field), but access is controlled by Merkle proof verification. Only wallets that can prove membership in the authorized group can use the key after on-chain verification.
In production, the key would be encrypted per-receiver or derived using ECDH (Elliptic Curve Diffie-Hellman).
A: The unlockAccess function verifies that msg.sender (the caller) is in the authorized Merkle tree. Even if someone copies the token, they cannot generate a valid Merkle proof unless their wallet address is in the original authorized list.
A: Efficiency and privacy:
- Gas: Storing 1,000 wallets costs ~$50, storing 1 root costs ~$0.50
- Privacy: Root reveals nothing about group members
- Scalability: Proof size is O(log n), not O(n)
A:
| Feature | Traditional JWT | ZKPJWT |
|---|---|---|
| Storage | Centralized server | Decentralized blockchain |
| Trust | Trust server | Trust math & consensus |
| Privacy | Server sees all | Zero-knowledge proofs |
| Revocation | Database update | Update Merkle root |
| Scalability | Server limited | Merkle tree (O(log n)) |
A: For a receiver at position i in a tree of size n:
function generateProof(walletAddress, allWallets) {
const tree = createMerkleTree(allWallets);
const leaf = keccak256(walletAddress);
// Collect sibling hashes from leaf to root
const proof = [];
let index = allWallets.indexOf(walletAddress);
let levelSize = allWallets.length;
while (levelSize > 1) {
const siblingIndex = index % 2 === 0 ? index + 1 : index - 1;
proof.push(tree.getNode(currentLevel, siblingIndex));
index = Math.floor(index / 2);
levelSize = Math.ceil(levelSize / 2);
}
return proof;
}A: Current version (v1.0) uses keccak256 which is vulnerable to Grover's algorithm (reduces 256-bit to 128-bit security).
Roadmap includes:
- Phase 2: Replace with SHA3-512 or BLAKE3
- Phase 3: Lattice-based signatures (post-quantum)
A: Yes! Two approaches:
- Publish new root: Create new tree without revoked wallets
- Time-based expiry: Add
validUntiltimestamp in contract - Blacklist contract (planned): Separate contract for revoked addresses
A: Theoretical limit: 2^256 (unlimited)
Practical limits:
- Proof size: log₂(n) hashes
- Gas cost: ~6,000 gas per proof level
- Client performance: Tested up to 10,000 wallets
Examples:
- 100 wallets: 7 proof hashes, ~42,000 gas
- 1,000 wallets: 10 proof hashes, ~60,000 gas
- 1,000,000 wallets: 20 proof hashes, ~120,000 gas
A: ZKPJWT can complement traditional auth:
// Hybrid approach
async function authenticate(user) {
// 1. Traditional login (email/password)
const session = await loginUser(user.email, user.password);
// 2. Check if user has Web3 wallet
if (user.walletAddress) {
// 3. Verify on-chain authorization
const hasAccess = await verifyZKPJWT(user.walletAddress, resourceId);
session.zkpVerified = hasAccess;
}
return session;
}A: Arbitrum inherits Ethereum security (Optimistic Rollup):
- L1 fallback: Data available on Ethereum mainnet
- 7-day challenge period: Fraud proofs protect against invalid states
- Decentralized sequencer (coming): No single point of failure
For critical applications, consider:
- Multi-chain deployment (Polygon zkEVM, zkSync)
- IPFS backup for Merkle roots
- Hybrid verification (on-chain + client-side)
- TypeScript library with core functions
- Circom circuit design
- Solidity verifier contract
- React demo application
- Documentation
- Rust contract with Arbitrum Stylus
- Full ZK proof generation and verification
- NPM package publication
- Security audit
- Multi-chain support (Polygon zkEVM, zkSync)
- Mobile SDK (React Native)
- Recursive proofs for batch verification
- Decentralized key management
Contributions are welcome! Please read CONTRIBUTING.md for guidelines.
# Fork and clone
git clone https://github.com/YOUR_USERNAME/zkp-jwt.git
# Create feature branch
git checkout -b feature/amazing-feature
# Commit changes
git commit -m 'Add amazing feature'
# Push and create PR
git push origin feature/amazing-featureThis project is licensed under the MIT License - see LICENSE file.
DevCristobalvc
- GitHub: @DevCristobalvc
- Devfolio: @DevCristobalvc
- Arbitrum ARG25 Program for support and resources
- Invisible Garden for program coordination
- Circom and SnarkJS teams for ZK tools
- MerkleTreeJS library maintainers
- Arbitrum Stylus Documentation
- Circom Documentation
- JWT RFC 7519 Standard
- Zero-Knowledge Proofs: An Illustrated Primer
Built with ❤️ for Arbitrum ARG25