Contents
Whether you build in traditional software or Web3, you never want to see a bug. You want users to interact with that code as it’s intended to function. You want their assets to be safe. You want their personal information to be private. Matter of fact, you want your assets and information to be secure too. That’s why the concept of production-hardening code exists.
Production-readiness in traditional software involves ensuring the software is secure, scalable, performant, and maintainable, and developers often leverage CI/CD pipelines, automated testing, and logging to achieve this readiness.
In traditional software development, bugs or vulnerabilities can often be patched with a simple update. But in the world of Web3, things work a little differently.
The Difference Between Production-Readiness in Traditional Software and Web3
Deploying code on a blockchain introduces new attack vectors and variables that make thorough testing even more important than it is in traditional software. Perhaps most importantly, there is no un-do button. You can’t roll back code once it’s been deployed or patch a problem with a simple update.
Blockchains are immutable, so any mistakes or vulnerabilities you deploy are permanently on-chain for all to see. Oops. This is even more true on Stacks because Clarity contracts are not compiled and are human-readable on-chain.
Alongside immutability, there are a few other security issues specific to Web3 that are worth mentioning here:
- Decentralization: Web3 applications operate in a decentralized environment, meaning there is no central authority to mediate disputes, recover lost funds, or fix bugs.
- Public code: Smart contract code is public. While in the long run, public, open source code makes for a more resilient system, it comes with attack vectors such as unchecked external contract calls, reentrancy attacks, unguarded state modifications, integer overflows/underflows, and more.
- Economic incentives: Smart contracts often handle real assets, in the form of digital tokens and NFTs, and the public can see those assets, introducing a higher level of risk. Mistakes in code can lead to significant financial loss.
- Blockchain networks: Different networks operate under different consensus algorithms that require additional consideration for security.
- Private Key Management: Unlike centralized systems where credentials can be reset, losing a private key in Web3 often means losing access to funds permanently.
- Contract dependencies: Your code may depend on other smart contracts, such as an oracle or a bridge, which can introduce third-party risk to your project.
All of these security issues mean that:
- A) There are new categories of security risk in Web3.
- B) Those risks can come with material consequences for you and/or your users.
- C) Fixing a vulnerability on-chain is a more involved process (e.g. deploying entirely new contracts, moving funds from compromised wallets, etc), but even then you may not be able to undo all of the damage the vulnerability caused.
As a result, it’s even more critical for you to harden your code in Web3, perform thorough testing, and implement robust monitoring strategies. What does that look like in practice? We thought you’d never ask.
Leverage a Production-Ready Checklist
To ensure your app or smart contract is production-ready, we pulled together a simple checklist that you can use in your development.
1. Adopt Lean DevOps Strategies
To ensure a smooth deployment process, adopt lean DevOps strategies, which include continuous integration and continuous delivery (CI/CD) pipelines. As discussed in Lean DevOps Strategies for Your Web3 Project, leveraging tools like GitHub Actions and GitLab CI/CD can help automate your deployment pipelines while ensuring code quality and consistency.
2. Implement Comprehensive Testing and Auditing
Production-readiness involves exhaustive testing. In the world of smart contracts, that involves several categories of testing:
- Unit tests: Ensure every function and method in your code behaves as expected. Learn how to create unit tests in the Clarinet SDK.
- Integration tests: Test interactions between your code and other smart contracts as well as network entities (e.g. miners and nodes). Learn how to create integration tests in the Clarinet SDK.
- Stress tests: Simulate network congestion and high transaction loads.
- Audits: Conduct code audits with third-party services specializing in blockchain security to identify vulnerabilities and potential attack vectors before any major deployment or upgrade.
3. Leverage Programmatic API Access
Utilize programmatic API access to chainhook and devnet for CI/CD workstreams. You can programmatically update all of your chainhooks at once as well as start and stop devnet, a private blockchain environment complete with its own blockstream, miners, nodes, and API for end-to-end testing.
4. Set Up Contract Monitoring
Take advantage of new contract monitoring tools available in the Hiro Platform. With this new feature, you can understand how people are interacting with your contract on-chain, giving you insight for future optimizations.
You can also set up automated alerts (email or webhook) for your contracts in order to detect suspicious activity around your contracts. You can configure alerts to fire when specific functions are called with particular argument values or by particular addresses. Configuring alerts for specific contract events can help you respond more quickly in sensitive situations.
5. Use Best Practices for Private Key Management
You’d be surprised how many hacks stem from simple security breaches. Make sure you securely manage your private keys related to your project. That includes things like always using hardware wallets, regularly rotate keys, enforce access controls for who on your team can use keys, and consider implementing a multi-sig for your treasury or other sensitive operations.
6. Plan for Fail-Safes and Emergency Upgrades
You can control for bugs as much as you can, but sometimes things happen. Devs are clever, and they can sometimes find ways to use your code in ways you didn’t anticipate. When designing your project, consider including fail-safes and building out processes for emergency upgrades. While contracts are immutable once deployed, you can deploy new versions of your contracts to upgrade your app. Make sure you have a deployment plan in place, so you can deploy a hot fix in the event you need to.
7. Regularly Update Dependencies
Always keep your dependencies up to date, especially for any libraries and frameworks you’ve used in your development. This can help reduce any vulnerabilities originating from those third-party packages.
Ship More Confidently
With the immutability of smart contracts and the high economic stakes involved, deploying code on a blockchain introduces a greater need for rigor in testing and hardening code for production.
By following this production-ready checklist, you can deploy more safely and more confidently on Stacks. Remember: be thorough, iterate, and stay vigilant to keep your app secure and robust. Happy coding, anon.
