Menu
Services
Blog
Tools
- Software
- Blockchain
- Web3 product
- Smart Contracts
- Mobile app
- Web platform
- AWS Cloud
- NFT marketplace
- DeFi
- Fintech
- AI product
- dApp
- Crypto wallet
Rumble Fish helps entrepreneurs build and launch bespoke digital products.
We take care of the technology, so you can focus on your business
Join the ecosystem
of our satisfied customers:
of our satisfied customers:
Who we are?
Hi there! We're Rumble Fish - a team of world-class experts in bespoke software development. Our engineers are highly skilled in blockchain, cloud solutions, and defi/fintech development. Our strength and pride is the ability to take ownership of the entire development process and be a true partner and advisor for our customers. Our mission is to craft state-of-the-art digital products using battle-tested technologies. Try us!
0uniquely skilled devs
0pet-friendly office
0years in business
0projects
0passion for coding
What do we do?
Software Development Services and Skills for your needs To deliver the highest quality of services, our experts are always
gaining new skills and knowledge. That’s how we make sure our
solutions follow the latest industry standards and take advantage
of the most innovative technologies.
Blockchain Software Development
Our team is well-versed and experienced in various blockchain development tools and technologies. Our unique skillset allows us to be at the forefront of Web3 development services so if you’re looking for a trusted IT partner to boost your decentralized product - look no further!
Zero-Knowledge Proof Development
We deliver production-ready zero-knowledge proof solutions that actually ship to mainnet, specializing in custom ZK development, rollup scaling solutions, and privacy-preserving smart contracts that reduce processing times from hours to minutes. Try us!
XRPL Blockchain Development
We build fast, compliant, and cost-effective blockchain solutions on the XRP Ledger. From payment systems and tokenization platforms to enterprise DeFi applications, our team delivers production-ready systems that work when billions are on the line.
Smart Contract Development
We build smart contracts that handle real business complexity without the usual blockchain headaches. From DeFi protocols to custom on-chain systems, we deliver production-ready solutions that scale.
DeFi Development
Decentralized Finance (DeFi) development requires an extensive amount of blockchain knowledge, as well as a great understanding of financial mechanisms. We’ve got both that bases covered! Our team has successfully built an impressive number of DeFi products like cryptocurrency exchanges, dApps, lending protocols, or staking platforms. Try us!
AWS Cloud Solutions
Our experienced team will take your AWS cloud solutions to the next level. AWS provides purpose-built tools to support your needs, and it is the preferred choice for any blockchain project. From the plethora of cloud tools and solutions offered by Amazon Web Services, we’ll help you choose and implement the ones that serve your business the best way possible.
AI Chat Assistant Development
AI chatbots can bring value to a wide range of industries by enhancing customer interactions, streamlining processes, and improving overall efficiency. We'll craft a perfect AI assistant for your product.
Fintech Software Development
Looking for a skilled team to help you build an advanced fintech platform able to compete with the biggest in the game? At Rumble Fish, we’ve got what it takes to engineer innovative financial technology systems. We offer end-to-end fintech software development, consulting, and expertise.
Dedicated Development Teams
Our experts provide you with knowledge, skills, and experience that elevates every project to another level. We’ll gladly take ownership of the entire process and guide you and your team through the intricacies of cutting-edge technology development.
Web Development
If you’re in need of professional web development services, look no further! Rumble Fish's talented team has extensive experience in delivering top-tier web apps and websites with the use of battle-tested tools and technologies like React or Nest. We know just the right solutions to exceed your business requirements.
Mobile App Development
Whether you need an Android, an IOS app, or both, the Rumble Fish team is here to help you deliver the beautiful and efficient mobile product that your customers will simply love to use! We craft fast and secure mobile apps with a wow factor to help our customers grow their businesses and reach their goals quicker.
IT services for your startup
If you're looking for a team capable of turning your product concept into a beautiful and technologically intricate digital solution - look no further! Rumble Fish is your trusted software development partner ready to take you through the entire process of custom digital product creation - from the early stages of ideation to the post-launch support. Whether you're on a mission to build a mobile app, a Web3 product, or an advanced platform - we are here for you!
UI/UX
We design sleek, intuitive, and highly effective interfaces to help you overcome your business challenges. After carefully evaluating and understanding your requirements we switch to the designing mode - the end goal is the beautiful digital solution that people love to use!
Testimonials
See what our customers say about working with us“
Latest case studyBuilding an AI-Driven Football Manager Game for Panenka
Building an AI-Driven Football Manager Game for Panenka
Collaboration timeframe:1 year
Services:Game Development, AI Research and Development, Front-end Development, Back-end Development, UX/UI Design
We're trusted by global innovators and leaders.Join them!
TURNTABLE
A hybrid of a social network and a music appTURNTABLE
MAKERDAO
The first truly decentralized stablecoin crypto on EthereumMAKERDAO
ZBAY
A private inbox, wallet, and marketplace all in oneZBAY
VERIFYID
An identity verification MVPVERIFYID
Rumblefish Blog
Tauri vs. Electron: The Lightweight Champion of Desktop Apps
By Oskar KarczOne of my very first computer-related memories is the moment I launched the epic game called Deluxe Ski Jump 2. For me, as a kid, it was kind of magic: I was able to double-click on the icon and, a few seconds later, be a pro ski jumper. Over 20 years later, this is still magic, but at least I know what kind of magic is behind it. Let’s talk about desktop apps. Framework: A Developer’s MultitoolI also believe that, over 20 years later, building desktop apps is not as cumbersome as it used to be, and there are many great frameworks out there that help to achieve this. First of all, let’s explain, for the sake of clarity, what a framework is. You can think of it as a ready-made toolkit, a set of libraries, tools, and conventions that provide structure for building applications. You can write your app by plugging into the framework’s lifecycle and patterns, which simply makes dev life easier. So far, the most popular framework for building desktop apps has been, and probably still is, Electron, but a new player has entered the game. His name is Tauri. My name is Tauri. 2.0 Tauri.As Tauri’s official documentation says, Tauri is a framework for building tiny, fast binaries for all major desktop and mobile platforms. Sounds cool, doesn’t it? But what does that actually mean? Well, let’s assume you want to build a desktop application for all major platforms: Linux, macOS, and Windows. It’s quite obvious that you want to develop the app codebase once and then just build three different versions suitable for each of the above platforms. This is, of course, about both your backend and frontend code. And here’s where Tauri comes to you and says, Hello there! Take my hand and let me help you do this!, which Tauri’s docs explain in other words: Developers can integrate any frontend framework that compiles to HTML, JavaScript, and CSS for building their user experience while leveraging languages such as Rust, Swift, and Kotlin for backend logic when needed. Electron vs. TauriBut haven’t I just written that there was already a leading framework, Electron, which was doing the same? Yes, but Tauri has a slightly different approach and advantages over the former. Electron is like packing your own mini web browser (Chromium) with your app, so it looks the same everywhere. It’s easy for web developers and has tons of plugins, but it makes apps bigger. Tauri is like borrowing the computer’s built‑in browser to show your app and using a fast Rust helper behind the scenes. Apps are much smaller and often use less memory, but you depend on each system’s web engine.Now that we know the difference, we can decide which framework is better for us and why this is (probably) Tauri. Creating a demo project is a piece of cake, and an officially maintained utility tool guides you by the hand through the first steps of the process. The playground is built; now you can build sandcastles or whatever you want. But don’t forget about security. Fortunately, Tauri hasn’t forgotten and takes security very seriously. The framework provides the Isolation Pattern, which (as the docs say) is a way to intercept and modify Tauri API messages sent by the frontend before they get to Tauri Core, all with JavaScript. The secure JavaScript code that is injected by the Isolation pattern is referred to as the Isolation application. If you’re interested in how it works, I strongly encourage you to take a look here. SummaryIs Tauri the magician who pulls a rabbit (or another Deluxe Ski Jump 2) out of a hat? No. But it's the perfect toolkit for anyone who wants to build a secure cross-platform desktop app. As a full-stack software developer, I had the opportunity to work with it, and I must say I really enjoyed it! Sure, the framework is still not perfect and (fortunately) is still being actively improved, but hopefully in 20 years it will be more mature than I am. And it will still give as much fun as playing Deluxe Ski Jump 2.
Understanding Zero-Knowledge Proof Development: Key Concepts and Practical ApplicationsZKP development is the process of designing, implementing, and deploying zero-knowledge proof systems that enable privacy-preserving verification in blockchain applications. In this guide, you'll learn what ZKP development entails, essential frameworks, and how to build production-ready ZKP applications. This comprehensive guide covers ZKP development fundamentals, popular frameworks (Circom, Noir, gnark), implementation strategies, and real-world deployment examples. Whether you're building privacy-preserving transactions, scalable Layer 2 solutions, or decentralized identity systems, you'll find practical insights for creating secure zero-knowledge protocols. We'll explore how zero-knowledge proofs work in practice, examine proof generation techniques, and demonstrate how to integrate cryptographic proof systems into modern applications while maintaining privacy and ensuring data security. Understanding ZKP Development: Key Concepts and DefinitionsCore ZKP Development ConceptsZKP development centers on creating systems where one party (the prover) can demonstrate knowledge of sensitive information to another party (the verifier) without revealing the underlying data. In practical terms, this involves designing zk circuits, implementing constraint systems, and orchestrating proof generation workflows.Essential terminology includes R1CS (Rank-1 Constraint System) circuits, which define mathematical relationships, arithmetic circuits that perform computations on private inputs, witnesses containing secret data, and proving keys that enable the creation of cryptographic proofs. The verification process relies on verifying keys to confirm the statement's truth without accessing the underlying information. The distinction between interactive zero-knowledge proofs and non-interactive zero-knowledge approaches is crucial for developers. Interactive proofs require multiple rounds of communication between parties, while non-interactive systems generate standalone proofs suitable for smart contracts and decentralized applications.Development Ecosystem RelationshipsZKP development connects directly to blockchain scalability through zk-rollups, privacy through confidential transactions, and identity verification via decentralized identity protocols. Modern proving systems like Groth16 and PLONK integrate with circuit languages such as Circom, enabling developers to build verifiable computations for smart contract applications. The relationship between frontend development tools and backend cryptographic libraries is fundamental. Developers use frameworks like SnarkJS for browser-based proof generation, while libraries like arkworks provide high-performance cryptographic primitives for Rust applications. This ecosystem enables privacy-preserving transactions across decentralized exchanges and maintains transaction privacy in complex financial applications. Hash functions, digital signature schemes, and range proofs serve as building blocks for larger zero-knowledge protocols. Understanding how these components interact helps developers optimize proof size, verification time, and overall system performance. Why ZKP Development is Important in Blockchain and Web3Privacy preservation represents the primary driver for ZKP adoption, enabling confidential transactions and private smart contracts without revealing sensitive data. Users can prove possession of funds, verify identity attributes, or demonstrate compliance without exposing proprietary data or risking data breaches. Scalability solutions demonstrate zero-knowledge proofs' transformative impact on blockchain infrastructure. Zk-rollups like Polygon zkEVM and StarkNet reduce Ethereum gas costs by over 90%, processing thousands of transactions per second. These systems compress hundreds of transactions into single cryptographic proofs, dramatically improving throughput and reducing network congestion. Regulatory compliance benefits emerge through privacy-preserving verification mechanisms. Organizations can satisfy GDPR and HIPAA requirements while maintaining data privacy, proving compliance without revealing sensitive information. This approach prevents identity theft and unauthorized access to private information while enabling necessary auditing and verification processes. Major Layer 2 ZKP solutions currently process millions of transactions weekly with billions in total value locked across platforms like Polygon zkEVM, zkSync Era, and StarkNet. Modern verification systems achieve 95% improvements in processing time compared to traditional proof systems. Step-by-Step Guide to ZKP DevelopmentStep 1: Environment Setup and Framework SelectionInstalling development tools varies by chosen framework. JavaScript developers should install Node.js (v18+) and npm, then set up Circom with SnarkJS for browser-compatible zero-knowledge proof generation. Rust developers can configure Noir for improved syntax and error handling, while Go developers may prefer gnark for enterprise applications.For Circom setup, install the compiler and SnarkJS library:npm install -g circom snarkjs
Configure your development environment with recommended VS Code extensions for syntax highlighting and debugging. Set up git hooks for constraint counting and circuit optimization tracking. For production applications, participate in or verify trusted setup ceremonies to maintain security assumptions. Development environment checklist includes: testing framework integration, constraint visualization tools, performance monitoring utilities, and formal verification tools. Establish clear build processes for circuit compilation, key generation, and proof verification to streamline development workflows.Step 2: Circuit Design and ImplementationDesigning constraint systems requires careful analysis of your specific use case, whether proving age verification, balance proofs, or vote validity. Each logical operation translates to mathematical constraints, directly impacting proof generation time and verification complexity. Writing circuits in Circom syntax involves defining input signals, implementing logic gates, and ensuring proper constraint coverage. Here's a simple example for range proof verification:template RangeProof(n) {
signal input value; // Secret value to prove is in range
signal input min; // Minimum allowed value
signal input max; // Maximum allowed value
signal output valid; // 1 if valid, 0 if invalid
// Check value >= min
component geq = GreaterEqualThan(n);
geq.in[0] <== value;
geq.in[1] <== min;
// Check value <= max
component leq = LessEqualThan(n);
leq.in[0] <== value;
leq.in[1] <== max;
// Both conditions must be true (1 * 1 = 1)
valid <== geq.out * leq.out;
}
Testing circuits with sample inputs and debugging constraint violations prevents production vulnerabilities. Use formal verification tools when available, as under-constrained circuits represent the most common security vulnerability in SNARK applications, potentially allowing false statements to pass verification.Step 3: Integration and DeploymentGenerating, proving, and verification keys requires executing trusted setups for production circuits. Universal trusted setup approaches like those used in PLONK reduce security risks compared to circuit-specific ceremonies, though they may increase proof size and verification time. Integrating zero-knowledge proof generation into frontend applications demands careful consideration of user experience. Implement web workers to prevent blocking UI threads during proof generation, especially for circuits exceeding 10,000 constraints. Cache generated proofs when possible to avoid repeated computation.Deploy verifier smart contracts to Ethereum, Polygon, or other EVM-compatible chains using standard deployment tools. Current Groth16 verification costs approximately 150-200k gas (~$5-15 depending on gas prices), while PLONK verification requires around 600-800k gas. Consider Layer 2 deployment for cost-sensitive applications to achieve 90%+ cost reductions. Common ZKP Development Mistakes to AvoidUnder-constrained circuits represent the most critical security vulnerability in SNARK applications. This occurs when circuits don't properly constrain all possible inputs, allowing malicious provers to generate valid proofs for false statements. Always verify that every logical condition translates to appropriate mathematical constraints, and use formal verification tools to detect potential gaps.Trusted setup security failures occur when developers use development keys in production environments or participate improperly in ceremony processes. Never reuse trusted setups between different circuits, and ensure ceremony participants follow proper security protocols. Consider using universal setups or proof systems without trusted setups (like STARKs or Halo2) for applications requiring long-term security.Performance bottlenecks typically arise from unoptimized constraint counts leading to proof generation times exceeding acceptable user experience thresholds. Profile your circuits early in development, minimize redundant constraints, and consider recursive proof techniques for complex applications. Implement proper error handling for proof generation failures and provide clear progress indicators.Frontend integration issues include blocking main threads during cryptographic operations and inadequate error handling for proof generation failures. Use web workers consistently, implement progress indicators for long-running operations, and provide clear error messages for constraint violations or invalid inputs.Pro Tip: Implement comprehensive testing suites including constraint counting, witness generation validation, and end-to-end proof verification. Use property-based testing and fuzzing techniques to identify edge cases that might compromise security or cause unexpected failures. Real-Life ZKP Development Example and WalkthroughCase Study: Building a Private Voting SystemOur voting system implementation demonstrates practical ZKP development for governance applications requiring voter privacy and result verifiability. The system enables participants to prove valid vote casting without revealing individual choices, while maintaining public verification of final tallies.System Requirements:Voter privacy (choices remain secret)Double-voting preventionEligible voter verificationPublic result verificationScalable to 1000+ votersImplementation Architecture:Voter Registration CircuitGenerates a unique nullifier for each eligible voterCreates a Merkle tree of registered votersIssues a registration proof without revealing identityVote Validity CircuitProves voter eligibility using Merkle proofValidates vote format (exactly one choice selected)Generates a nullifier to prevent double votingEncrypts the vote choice for privacyTally AggregationHomomorphic addition of encrypted votesFinal decryption reveals only aggregate resultsIndividual votes remain permanently privateTechnical Implementation:// Simplified vote validity circuit
template VoteValidity(levels) {
signal input vote; // 0 or 1 (private vote choice)
signal input nullifier; // Unique voter identifier
signal input secret; // Voter's private key
signal input pathElements[levels];
signal input pathIndices[levels];
signal output nullifierHash;
signal output commitmentHash;
// Ensure vote is binary (0 or 1)
component voteCheck = Num2Bits(1);
voteCheck.in <== vote;
// Verify voter membership in registered set
component merkleProof = MerkleTreeChecker(levels);
merkleProof.leaf <== secret;
merkleProof.pathElements <== pathElements;
merkleProof.pathIndices <== pathIndices;
// Generate nullifier to prevent double voting
component nullifierHasher = Poseidon(2);
nullifierHasher.inputs[0] <== secret;
nullifierHasher.inputs[1] <== nullifier;
nullifierHash <== nullifierHasher.out;
// Create vote commitment
component commitmentHasher = Poseidon(3);
commitmentHasher.inputs[0] <== vote;
commitmentHasher.inputs[1] <== secret;
commitmentHasher.inputs[2] <== nullifier;
commitmentHash <== commitmentHasher.out;
}
Performance Results:Circuit constraints: ~15,000 for vote validityProof generation: 800ms average on desktop browsersProof size: 288 bytes (Groth16)Verification time: 12ms per proofGas cost: ~180k gas per vote verification (~$8-12 on Ethereum mainnet)Total system capacity: 2000+ votes processed in under 5 minutesMetricBefore ZKPAfter ZKP ImplementationVote PrivacyNone (public ballots)Complete (zero-knowledge)Verification Time5-10 seconds per vote12ms per proofScalability50 votes/minute5000+ votes/minuteCost per Vote$25-50 (traditional verification)$2-12 (depending on network) FAQs about ZKP DevelopmentQ1: Which ZKP framework should I choose for a DeFi application? A1: Circom with Groth16 offers small proofs (288 bytes) and fast verification, ideal for DeFi applications where gas costs matter. Consider Noir for a better developer experience with improved debugging, or gnark for enterprise applications requiring high performance. For applications needing long-term security without trusted setups, evaluate Halo2 despite larger proof sizes.Q2: How long does it take to generate proofs in production? A2: Simple circuits with 1000 constraints generate proofs in 100-2000ms on modern browsers, while complex circuits with 100k+ constraints may require 10-60 seconds depending on device capabilities. Mobile devices typically experience 3-10x slower performance than desktop environments. Consider server-side proving for complex circuits to maintain a good user experience.Q3: Can ZKP applications run on mobile devices? A3: Yes, frameworks like SnarkJS support WebAssembly for mobile browsers, enabling on-device proof generation. However, proof generation is significantly slower on mobile devices. For circuits over 10k constraints, consider hybrid approaches with server-side proving or simplified mobile-specific circuits.Q4: What are the current gas costs for ZKP verification? A4: Groth16 verification costs approximately 150-200k gas ($5-15 depending on current gas prices), while PLONK verification requires around 600-800k gas. Layer 2 solutions like Polygon reduce costs by 90%+, making frequent verification economically viable. STARKs have higher verification costs (~2-5M gas) but offer post-quantum security.Q5: How do I handle trusted setup security? A5: Participate in or verify established trusted setup ceremonies for production applications. Never reuse setups between different circuits. For maximum security, consider proof systems without trusted setups (STARKs, Halo2) or universal setups (PLONK) that can be reused across multiple circuits safely. Conclusion: Key Takeaways for ZKP DevelopmentStart with established frameworks like Circom or Noir for production applications rather than building cryptographic primitives from scratch. These mature ecosystems provide battle-tested implementations, extensive documentation, and active community support for troubleshooting complex circuit design challenges. Focus on circuit optimization early in development, as constraint count directly impacts user experience and operational costs. Every additional constraint increases proof generation time and verification complexity. Profile circuits continuously and implement constraint counting in your build processes to catch performance regressions. Plan for scalability using Layer 2 solutions and consider recursive proofs for complex applications requiring multiple verification steps. Universal trusted setup approaches reduce security risks compared to circuit-specific ceremonies, though they may increase computational requirements. Implement comprehensive testing including formal verification to prevent costly security vulnerabilities. Zero-knowledge protocols require rigorous validation of constraint coverage, witness generation accuracy, and end-to-end verification workflows. Security failures in production can compromise user privacy and system integrity.Next Steps:Join ZKP developer communities (Telegram, Discord) for knowledge sharingExperiment with sample projects using established frameworksContribute to open-source ZKP tools and librariesStay updated with rapidly evolving cryptographic researchPractice with hackathons and developer challengesThe zero-knowledge ecosystem continues evolving rapidly, making continuous learning essential for maintaining current best practices and emerging optimization techniques. Focus on building practical experience while staying informed about theoretical advances that may impact production implementations.
Check a piece of expert knowledge
Tauri vs. Electron: The Lightweight Champion of Desktop AppsBy Oskar KarczSoftware Development
Understanding Zero-Knowledge Proof Development: Key Concepts and Practical ApplicationsZKP development is the process of designing, implementing, and deploying zero-knowledge proof systems that enable privacy-preserving verification in blockchain applications. In this guide, you'll learn what ZKP development entails, essential frameworks, and how to build production-ready ZKP applications. This comprehensive guide covers ZKP development fundamentals, popular frameworks (Circom, Noir, gnark), implementation strategies, and real-world deployment examples. Whether you're building privacy-preserving transactions, scalable Layer 2 solutions, or decentralized identity systems, you'll find practical insights for creating secure zero-knowledge protocols. We'll explore how zero-knowledge proofs work in practice, examine proof generation techniques, and demonstrate how to integrate cryptographic proof systems into modern applications while maintaining privacy and ensuring data security. Understanding ZKP Development: Key Concepts and DefinitionsCore ZKP Development ConceptsZKP development centers on creating systems where one party (the prover) can demonstrate knowledge of sensitive information to another party (the verifier) without revealing the underlying data. In practical terms, this involves designing zk circuits, implementing constraint systems, and orchestrating proof generation workflows.Essential terminology includes R1CS (Rank-1 Constraint System) circuits, which define mathematical relationships, arithmetic circuits that perform computations on private inputs, witnesses containing secret data, and proving keys that enable the creation of cryptographic proofs. The verification process relies on verifying keys to confirm the statement's truth without accessing the underlying information. The distinction between interactive zero-knowledge proofs and non-interactive zero-knowledge approaches is crucial for developers. Interactive proofs require multiple rounds of communication between parties, while non-interactive systems generate standalone proofs suitable for smart contracts and decentralized applications.Development Ecosystem RelationshipsZKP development connects directly to blockchain scalability through zk-rollups, privacy through confidential transactions, and identity verification via decentralized identity protocols. Modern proving systems like Groth16 and PLONK integrate with circuit languages such as Circom, enabling developers to build verifiable computations for smart contract applications. The relationship between frontend development tools and backend cryptographic libraries is fundamental. Developers use frameworks like SnarkJS for browser-based proof generation, while libraries like arkworks provide high-performance cryptographic primitives for Rust applications. This ecosystem enables privacy-preserving transactions across decentralized exchanges and maintains transaction privacy in complex financial applications. Hash functions, digital signature schemes, and range proofs serve as building blocks for larger zero-knowledge protocols. Understanding how these components interact helps developers optimize proof size, verification time, and overall system performance. Why ZKP Development is Important in Blockchain and Web3Privacy preservation represents the primary driver for ZKP adoption, enabling confidential transactions and private smart contracts without revealing sensitive data. Users can prove possession of funds, verify identity attributes, or demonstrate compliance without exposing proprietary data or risking data breaches. Scalability solutions demonstrate zero-knowledge proofs' transformative impact on blockchain infrastructure. Zk-rollups like Polygon zkEVM and StarkNet reduce Ethereum gas costs by over 90%, processing thousands of transactions per second. These systems compress hundreds of transactions into single cryptographic proofs, dramatically improving throughput and reducing network congestion. Regulatory compliance benefits emerge through privacy-preserving verification mechanisms. Organizations can satisfy GDPR and HIPAA requirements while maintaining data privacy, proving compliance without revealing sensitive information. This approach prevents identity theft and unauthorized access to private information while enabling necessary auditing and verification processes. Major Layer 2 ZKP solutions currently process millions of transactions weekly with billions in total value locked across platforms like Polygon zkEVM, zkSync Era, and StarkNet. Modern verification systems achieve 95% improvements in processing time compared to traditional proof systems. Step-by-Step Guide to ZKP DevelopmentStep 1: Environment Setup and Framework SelectionInstalling development tools varies by chosen framework. JavaScript developers should install Node.js (v18+) and npm, then set up Circom with SnarkJS for browser-compatible zero-knowledge proof generation. Rust developers can configure Noir for improved syntax and error handling, while Go developers may prefer gnark for enterprise applications.For Circom setup, install the compiler and SnarkJS library:npm install -g circom snarkjs
Configure your development environment with recommended VS Code extensions for syntax highlighting and debugging. Set up git hooks for constraint counting and circuit optimization tracking. For production applications, participate in or verify trusted setup ceremonies to maintain security assumptions. Development environment checklist includes: testing framework integration, constraint visualization tools, performance monitoring utilities, and formal verification tools. Establish clear build processes for circuit compilation, key generation, and proof verification to streamline development workflows.Step 2: Circuit Design and ImplementationDesigning constraint systems requires careful analysis of your specific use case, whether proving age verification, balance proofs, or vote validity. Each logical operation translates to mathematical constraints, directly impacting proof generation time and verification complexity. Writing circuits in Circom syntax involves defining input signals, implementing logic gates, and ensuring proper constraint coverage. Here's a simple example for range proof verification:template RangeProof(n) {
signal input value; // Secret value to prove is in range
signal input min; // Minimum allowed value
signal input max; // Maximum allowed value
signal output valid; // 1 if valid, 0 if invalid
// Check value >= min
component geq = GreaterEqualThan(n);
geq.in[0] <== value;
geq.in[1] <== min;
// Check value <= max
component leq = LessEqualThan(n);
leq.in[0] <== value;
leq.in[1] <== max;
// Both conditions must be true (1 * 1 = 1)
valid <== geq.out * leq.out;
}
Testing circuits with sample inputs and debugging constraint violations prevents production vulnerabilities. Use formal verification tools when available, as under-constrained circuits represent the most common security vulnerability in SNARK applications, potentially allowing false statements to pass verification.Step 3: Integration and DeploymentGenerating, proving, and verification keys requires executing trusted setups for production circuits. Universal trusted setup approaches like those used in PLONK reduce security risks compared to circuit-specific ceremonies, though they may increase proof size and verification time. Integrating zero-knowledge proof generation into frontend applications demands careful consideration of user experience. Implement web workers to prevent blocking UI threads during proof generation, especially for circuits exceeding 10,000 constraints. Cache generated proofs when possible to avoid repeated computation.Deploy verifier smart contracts to Ethereum, Polygon, or other EVM-compatible chains using standard deployment tools. Current Groth16 verification costs approximately 150-200k gas (~$5-15 depending on gas prices), while PLONK verification requires around 600-800k gas. Consider Layer 2 deployment for cost-sensitive applications to achieve 90%+ cost reductions. Common ZKP Development Mistakes to AvoidUnder-constrained circuits represent the most critical security vulnerability in SNARK applications. This occurs when circuits don't properly constrain all possible inputs, allowing malicious provers to generate valid proofs for false statements. Always verify that every logical condition translates to appropriate mathematical constraints, and use formal verification tools to detect potential gaps.Trusted setup security failures occur when developers use development keys in production environments or participate improperly in ceremony processes. Never reuse trusted setups between different circuits, and ensure ceremony participants follow proper security protocols. Consider using universal setups or proof systems without trusted setups (like STARKs or Halo2) for applications requiring long-term security.Performance bottlenecks typically arise from unoptimized constraint counts leading to proof generation times exceeding acceptable user experience thresholds. Profile your circuits early in development, minimize redundant constraints, and consider recursive proof techniques for complex applications. Implement proper error handling for proof generation failures and provide clear progress indicators.Frontend integration issues include blocking main threads during cryptographic operations and inadequate error handling for proof generation failures. Use web workers consistently, implement progress indicators for long-running operations, and provide clear error messages for constraint violations or invalid inputs.Pro Tip: Implement comprehensive testing suites including constraint counting, witness generation validation, and end-to-end proof verification. Use property-based testing and fuzzing techniques to identify edge cases that might compromise security or cause unexpected failures. Real-Life ZKP Development Example and WalkthroughCase Study: Building a Private Voting SystemOur voting system implementation demonstrates practical ZKP development for governance applications requiring voter privacy and result verifiability. The system enables participants to prove valid vote casting without revealing individual choices, while maintaining public verification of final tallies.System Requirements:Voter privacy (choices remain secret)Double-voting preventionEligible voter verificationPublic result verificationScalable to 1000+ votersImplementation Architecture:Voter Registration CircuitGenerates a unique nullifier for each eligible voterCreates a Merkle tree of registered votersIssues a registration proof without revealing identityVote Validity CircuitProves voter eligibility using Merkle proofValidates vote format (exactly one choice selected)Generates a nullifier to prevent double votingEncrypts the vote choice for privacyTally AggregationHomomorphic addition of encrypted votesFinal decryption reveals only aggregate resultsIndividual votes remain permanently privateTechnical Implementation:// Simplified vote validity circuit
template VoteValidity(levels) {
signal input vote; // 0 or 1 (private vote choice)
signal input nullifier; // Unique voter identifier
signal input secret; // Voter's private key
signal input pathElements[levels];
signal input pathIndices[levels];
signal output nullifierHash;
signal output commitmentHash;
// Ensure vote is binary (0 or 1)
component voteCheck = Num2Bits(1);
voteCheck.in <== vote;
// Verify voter membership in registered set
component merkleProof = MerkleTreeChecker(levels);
merkleProof.leaf <== secret;
merkleProof.pathElements <== pathElements;
merkleProof.pathIndices <== pathIndices;
// Generate nullifier to prevent double voting
component nullifierHasher = Poseidon(2);
nullifierHasher.inputs[0] <== secret;
nullifierHasher.inputs[1] <== nullifier;
nullifierHash <== nullifierHasher.out;
// Create vote commitment
component commitmentHasher = Poseidon(3);
commitmentHasher.inputs[0] <== vote;
commitmentHasher.inputs[1] <== secret;
commitmentHasher.inputs[2] <== nullifier;
commitmentHash <== commitmentHasher.out;
}
Performance Results:Circuit constraints: ~15,000 for vote validityProof generation: 800ms average on desktop browsersProof size: 288 bytes (Groth16)Verification time: 12ms per proofGas cost: ~180k gas per vote verification (~$8-12 on Ethereum mainnet)Total system capacity: 2000+ votes processed in under 5 minutesMetricBefore ZKPAfter ZKP ImplementationVote PrivacyNone (public ballots)Complete (zero-knowledge)Verification Time5-10 seconds per vote12ms per proofScalability50 votes/minute5000+ votes/minuteCost per Vote$25-50 (traditional verification)$2-12 (depending on network) FAQs about ZKP DevelopmentQ1: Which ZKP framework should I choose for a DeFi application? A1: Circom with Groth16 offers small proofs (288 bytes) and fast verification, ideal for DeFi applications where gas costs matter. Consider Noir for a better developer experience with improved debugging, or gnark for enterprise applications requiring high performance. For applications needing long-term security without trusted setups, evaluate Halo2 despite larger proof sizes.Q2: How long does it take to generate proofs in production? A2: Simple circuits with 1000 constraints generate proofs in 100-2000ms on modern browsers, while complex circuits with 100k+ constraints may require 10-60 seconds depending on device capabilities. Mobile devices typically experience 3-10x slower performance than desktop environments. Consider server-side proving for complex circuits to maintain a good user experience.Q3: Can ZKP applications run on mobile devices? A3: Yes, frameworks like SnarkJS support WebAssembly for mobile browsers, enabling on-device proof generation. However, proof generation is significantly slower on mobile devices. For circuits over 10k constraints, consider hybrid approaches with server-side proving or simplified mobile-specific circuits.Q4: What are the current gas costs for ZKP verification? A4: Groth16 verification costs approximately 150-200k gas ($5-15 depending on current gas prices), while PLONK verification requires around 600-800k gas. Layer 2 solutions like Polygon reduce costs by 90%+, making frequent verification economically viable. STARKs have higher verification costs (~2-5M gas) but offer post-quantum security.Q5: How do I handle trusted setup security? A5: Participate in or verify established trusted setup ceremonies for production applications. Never reuse setups between different circuits. For maximum security, consider proof systems without trusted setups (STARKs, Halo2) or universal setups (PLONK) that can be reused across multiple circuits safely. Conclusion: Key Takeaways for ZKP DevelopmentStart with established frameworks like Circom or Noir for production applications rather than building cryptographic primitives from scratch. These mature ecosystems provide battle-tested implementations, extensive documentation, and active community support for troubleshooting complex circuit design challenges. Focus on circuit optimization early in development, as constraint count directly impacts user experience and operational costs. Every additional constraint increases proof generation time and verification complexity. Profile circuits continuously and implement constraint counting in your build processes to catch performance regressions. Plan for scalability using Layer 2 solutions and consider recursive proofs for complex applications requiring multiple verification steps. Universal trusted setup approaches reduce security risks compared to circuit-specific ceremonies, though they may increase computational requirements. Implement comprehensive testing including formal verification to prevent costly security vulnerabilities. Zero-knowledge protocols require rigorous validation of constraint coverage, witness generation accuracy, and end-to-end verification workflows. Security failures in production can compromise user privacy and system integrity.Next Steps:Join ZKP developer communities (Telegram, Discord) for knowledge sharingExperiment with sample projects using established frameworksContribute to open-source ZKP tools and librariesStay updated with rapidly evolving cryptographic researchPractice with hackathons and developer challengesThe zero-knowledge ecosystem continues evolving rapidly, making continuous learning essential for maintaining current best practices and emerging optimization techniques. Focus on building practical experience while staying informed about theoretical advances that may impact production implementations.Blockchain
Have an idea?
Let’s work
together!We will answer any questions you may have related to your startup journey!Do you prefer e-mail?
hello@rumblefish.pl
together!We will answer any questions you may have related to your startup journey!Do you prefer e-mail?
hello@rumblefish.pl
RUMBLEFISH POLAND SP Z O.O.Filipa Eisenberga 11/3 31-523 Kraków, Polska
NIP: 6772425725REGON: 368368380KRS: 0000696628
P: +48 601 265 364E: hello@rumblefish.dev
Copyright © 2025 RumblefishServicesBlockchain Software DevelopmentZero-Knowledge Proof DevelopmentXRPL Blockchain DevelopmentSmart Contract DevelopmentDeFi DevelopmentAWS Cloud SolutionsAI Chat Assistant DevelopmentFintech Software DevelopmentDedicated Development TeamsWeb developmentMobile developmentIT Services for startupUI/UXView all services
ToolsEVM Debugger
CareersJoin Our Team
