A bonfire of vanities in Delhi 

Strategy shares fell 4.56% to $93.28 on July 31 after the company reported an $8.22 billion quarterly loss and prioritized restoring its STRC preferred stock to its $100 par value.

Strategy stock slides after $8.22B quarterly loss

Strategy stock traded as low as $89.21 on Thursday before recovering to close at $93.28. The 4.56% decline took the Nasdaq-listed company below $90 during the session for the first time since July 1.

The decline followed Strategy’s second-quarter results, which included an $8.32 billion unrealized loss on its Bitcoin holdings. That pushed the company to a net loss of $8.22 billion, or $24.45 per share, during the quarter.

Strategy held 843,775 BTC at the end of the reporting period, representing a 25% increase from the start of the year. The company acquired the holdings for approximately $63.69 billion at an average price of $75,476 per coin.

Lower Bitcoin prices reduced the market value of the position to about $54.77 billion. Under fair-value accounting rules, changes in Bitcoin’s market price flow through Strategy’s reported earnings, exposing quarterly results to large swings.

Operating revenue offered one positive data point. Revenue increased 6.9% from $114.5 million in the comparable period last year to $122.4 million.

Why Strategy is prioritizing STRC over immediate BTC purchases

Executive Chairman Michael Saylor said during the earnings call that Strategy would move away from directing all available funds toward immediate Bitcoin purchases. The company instead plans to maintain a combination of cash and BTC.

“Perhaps the best way to buy the most Bitcoin is not to buy the most Bitcoin immediately,” Saylor said.

Chief Executive Phong Le said Strategy would refrain from buying additional Bitcoin while STRC traded below its $100 par value. The company’s variable-rate preferred stock ended July 31 at approximately $89.

Strategy repurchased about $25 million of STRC between July 20 and July 24 while raising $544 million through sales of its common stock. The transactions indicate that management views support for the preferred share as necessary to preserve its broader capital-raising model.

Restoring STRC to par could improve investor confidence in Strategy’s preferred securities and make future issuance more efficient. Those instruments have become part of the company’s strategy for raising capital without relying exclusively on common-share sales or conventional debt.

Strategy also held a $3.75 billion cash reserve, giving it room to cover dividend and interest obligations without selling Bitcoin during a market downturn.

MSTR chart points to weak momentum near $90

The daily chart shows Strategy stock trading near the lower end of its recent consolidation range. Thursday’s decline took the price below the Bollinger Band midpoint at $96.04 and toward the lower band at $90.31.

A daily close below $90.31 could confirm renewed selling pressure and expose the late-June low around $81 to $82. That area marked the bottom of the stock’s decline before its July stabilization.

The Average Directional Index stood at 13.13. An ADX reading below 20 generally indicates that the market lacks a strong directional trend, suggesting Strategy shares remain in consolidation despite the latest bearish session.

On the upside, MSTR would first need to recover above the $96.04 midpoint. A sustained move above that level could place the upper Bollinger Band at $101.77 within reach.

The narrow distance between the bands also shows that volatility has contracted following the stock’s steep decline from its May high near $200. A break outside the $90.31–$101.77 range could determine its next short-term direction.

Wall Street analysts retain bullish Strategy targets

Benchmark maintained its buy rating on Strategy but reduced its price target from $570 to $435. Analyst Mark Palmer said Saylor’s focus on bringing STRC back to par could strengthen the company’s ability to raise funds for future Bitcoin purchases.

Benchmark also kept its ratings on Strategy after its Q2 call, similarly citing STRC preferred stock parity as now management’s central objective.

However, the firms split on price, with Benchmark cutting to $435 from $570 and TD Cowen at $260, after an $8.2 billion quarterly… pic.twitter.com/DVx2rWiHEb

— The Block (@TheBlockCo) July 31, 2026

Advertisement

H.C. Wainwright also maintained a buy rating and assigned Strategy stock a $325 target. The firm cited the company’s cash reserve and STRC repurchases as measures that could strengthen its balance sheet and limit the need to take on additional debt.

Both targets imply substantial upside from the July 31 closing price. However, their outlooks remain closely tied to Bitcoin’s performance and Strategy’s ability to issue securities on favorable terms.

For US investors, MSTR remains a publicly traded way to gain leveraged exposure to Bitcoin without holding the asset directly. That exposure also carries company-specific risks, including preferred-share obligations, equity dilution and earnings volatility caused by Bitcoin fair-value adjustments.

Bitcoin and STRC remain the next key catalysts

Strategy’s short-term stock performance will likely depend on whether STRC moves back toward $100 and whether Bitcoin recovers above the company’s average acquisition cost.

Management’s decision to preserve cash does not amount to abandoning its Bitcoin strategy. Instead, it delays immediate purchases while the company works to support the securities used to finance future acquisitions.

MSTR could remain range-bound while the ADX stays weak. A close below $90 would strengthen the downside case, while a recovery above $101.77 would signal that buyers are regaining control.

Galaxy Research, the research arm of Galaxy Digital, has expanded the on-chain scope of the Coldcard wallet incident after identifying 1,196 affected Bitcoin addresses. In a 41-minute window, those addresses lost a total of 1,082.65 BTC—worth about $70.2 million at the time the transactions occurred.

The new findings push earlier estimates further, helping clarify what attackers may have executed immediately after the vulnerable wallets generated seeds. Galaxy Research’s tracing covers movements between 1:10 AM and 1:51 AM UTC on July 30 across blocks 960,183 to 960,191, roughly 30 hours before Coldcard published its first security advisory.

Key takeaways

• Galaxy Research identified 1,196 addresses tied to the Coldcard incident and traced losses of 1,082.65 BTC in a 41-minute period.
• The identified activity occurred between 1:10 AM and 1:51 AM UTC on July 30, across blocks 960,183–960,191, about 30 hours before Coldcard’s initial advisory.
• Earlier estimates by AnchorWatch CEO Rob Hamilton were lower, pointing to 594.48 BTC moving through a tighter three-block window.
• Galaxy Research says the transactions share a distinctive pattern on-chain—identical 30 satoshis per virtual byte fees and no change outputs—but future sweeps may differ.

Galaxy Research broadens the attack map

Galaxy Research says it traced the Bitcoin movements tied to the incident to a specific burst of activity on July 30. The research effort focuses on addresses linked to the Coldcard wallet compromise that were swept between 1:10 AM and 1:51 AM UTC.

According to Galaxy Research, the losses accumulated across a short span of blocks—960,183 through 960,191—indicating that the attack likely operated with automation and repeated transaction structure rather than sporadic manual movement. At the time of the outgoing transfers, the 1,082.65 BTC figure was valued at approximately $70.2 million.

The timing is also notable: Galaxy Research’s tracing window began about a day before Coldcard’s first publicly issued security advisory, suggesting that the compromised funds were moved early and that the response cycle lagged behind the initial sweep.

Pattern matching helps confirm related transactions—within limits

In follow-up analysis, Galaxy Research said the identified transactions share a common signature. The company reported that the sweeps used identical 30 satoshis per virtual byte fees and that the transactions contained no change outputs.

Those characteristics are useful for investigators because they provide an on-chain fingerprint for clustering wallet-related activity, which can reduce the chances of misattributing unrelated transfers. Galaxy Research also cautioned that while the initial attack activity is identifiable through this pattern, later attacks against Coldcard-generated addresses may not preserve the same fingerprint.

For users and analysts, this distinction matters: it implies that incident totals based solely on one recognizable transaction structure could undercount additional rounds of activity if those later sweeps differed in fee settings or output behavior.

Earlier estimates were smaller, but based on a narrower window

Before Galaxy Research’s broader mapping, earlier preliminary analysis by AnchorWatch CEO and co-founder Rob Hamilton estimated that 594.48 BTC—about $38 million at the time—moved across 500 transactions within a three-block window.

Hamilton’s figures were drawn from a tighter segment of on-chain activity, reflecting how fast-moving wallet incidents often outpace early investigations. Galaxy Research’s expanded set effectively updates the picture by widening both the address set and the traced timeframe around the July 30 burst, nearly doubling the total BTC attributed to the sweep activity.

The divergence between estimates underscores a common challenge in incident response for self-custody systems: determining full scope can require days of tracing, clustering, and validation—particularly when attackers reuse similar logic across multiple transactions and destinations.

Coinkite acknowledges a firmware bug and advises seed migration

Coldcard’s manufacturer, Coinkite, has taken responsibility for the underlying issue. In an X post on Friday, Coinkite co-founder Rodolfo Novak said the company is working to determine the full scope of the problem and confirmed that it released a hotfix designed to remove a software fallback path.

Novak also emphasized a limitation of the mitigation: the update does not protect seeds generated on the vulnerable firmware. In practical terms, users who created seed phrases during the affected period were advised to move funds to a new seed.

This guidance aligns with the core risk in seed-based compromises—if a vulnerability affects how seed material or related execution paths behave, merely updating firmware may not retroactively secure already-generated keys. The immediate operational implication for affected holders is that recovery requires a transfer to safer key material, not just a device update.

What to watch next for affected users

Galaxy Research’s identification of a common on-chain sweep pattern offers a more structured basis for tracking related activity, but the company’s warning that future attacks may not match the same fingerprint suggests the incident may still evolve in how it appears on-chain. Users concerned about whether they generated seeds with vulnerable firmware should focus on migrating remaining balances to newly generated seeds and continue monitoring for any residual movement tied to addresses linked to the sweep logic.

Galaxy Research identified 1,196 addresses that lost 1,082.65 Bitcoin in a 41-minute window, expanding the estimated scope of the Coldcard wallet incident.

Galaxy Research, the research arm of crypto investment company Galaxy Digital, identified 1,196 addresses linked to the Coldcard wallet incident that lost 1,082.65 Bitcoin, worth about $70.2 million at the time of the transactions.

Galaxy Research traced the Bitcoin movements between 1:10 AM and 1:51 AM UTC on July 30 across blocks 960,183 to 960,191, about 30 hours before Coldcard published its first security advisory, according to an X post on Friday.

Earlier preliminary analysis of the Coldcard incident by AnchorWatch CEO and co-founder Rob Hamilton estimated that 594.48 Bitcoin, worth around $38 million, moved across 500 transactions within a three-block window.

Galaxy Research later said the identified transactions shared a pattern, including identical 30 satoshis per virtual byte fees and no change outputs. The company said the initial attack activity is identifiable on-chain through this pattern, but noted that future attacks against Coldcard-generated addresses may not follow the same fingerprint.

Coinkite co-founder Rodolfo Novak said in an X post on Friday that the company takes responsibility for the firmware bug and is working to determine the full scope of the issue.

Novak said Coinkite released a hotfix to remove the software fallback path, but warned that the update does not protect seeds generated on vulnerable firmware. He advised users who generated seeds on vulnerable firmware to move their funds to a new seed.

Related: SecondFi to wind down after $2.6M ADA theft linked to wallet flaw

Cointelegraph is committed to independent, transparent journalism. This news article is produced in accordance with Cointelegraph’s Editorial Policy and aims to provide accurate and timely information. Readers are encouraged to verify information independently.

A zero-knowledge proof lets one party prove to another that a statement is true without revealing any information beyond the truth of the statement itself. It is the cryptographic technique behind blockchain privacy, scalable rollups, and a growing number of identity verification systems.

The standard explanation of zero-knowledge proofs uses the cave analogy. Ali Baba knows the secret word to open a door inside a circular cave. He can prove he knows the word by entering from one side and exiting from the other, on demand, without ever saying the word out loud. After enough successful demonstrations, the verifier becomes statistically certain Ali Baba knows the secret.

This analogy is correct but incomplete. It captures the intuition but misses the machinery. In practice, zero-knowledge proofs are not about caves or doors. They are about polynomial commitments, elliptic curve pairings, and the mathematical properties that allow one party to encode a computation as a set of constraints and another party to verify that those constraints are satisfied without learning what values satisfied them.

This article explains what zero-knowledge proofs do, how the two dominant proof systems work, where they are deployed in production, and what they cannot do. If you have heard that zero-knowledge proofs solve all of blockchain’s privacy and scalability problems, the reality is more specific and more interesting.

The three properties

A zero-knowledge proof must satisfy three mathematical properties. Completeness means that if the statement is true and both the prover and verifier follow the protocol, the verifier will always accept the proof. Soundness means that if the statement is false, no cheating prover can convince the verifier to accept it, except with negligible probability. Zero-knowledge means the verifier learns nothing beyond whether the statement is true.

The third property is the counterintuitive one. How can you verify a computation without learning anything about it? The answer lies in the structure of the proof system. The prover encodes the computation as a polynomial equation, commits to that polynomial using a cryptographic commitment scheme, and then responds to random challenges from the verifier. The verifier checks the responses against the commitment without ever seeing the polynomial itself.

In non-interactive zero-knowledge proofs, which are the type used in blockchains, the random challenges are replaced by a hash function applied to the commitment. This is called the Fiat-Shamir heuristic, and it allows the prover to generate the entire proof without any back and forth communication. The resulting proof is a compact string of data that anyone can verify independently.

The mathematical foundation rests on the hardness of certain computational problems. For zk-SNARKs, security relies on the difficulty of computing discrete logarithms on elliptic curves. For zk-STARKs, security relies on the collision resistance of hash functions, which is considered a weaker and more conservative assumption. If either assumption turns out to be wrong, the corresponding proof system breaks. This is why the choice between zk-SNARKs and zk-STARKs involves tradeoffs beyond just proof size and verification speed.

zk-SNARKs: trusted setup, small proofs

zk-SNARK stands for Zero-Knowledge Succinct Non-interactive Argument of Knowledge. The word succinct is the key differentiator: a zk-SNARK proof is extremely small, typically a few hundred bytes, and can be verified in milliseconds regardless of how complex the underlying computation is.

The cost of this succinctness is the trusted setup. Most zk-SNARK constructions require an initial ceremony where a set of structured reference strings are generated. These strings are used by both provers and verifiers. If the random values used to generate them are not properly destroyed, anyone who retains them could create fake proofs that appear valid. This is sometimes called toxic waste.

Modern trusted setup ceremonies use multi-party computation protocols where hundreds or thousands of participants each contribute randomness. The security guarantee is that as long as at least one participant honestly destroys their random contribution, the setup is secure. Zcash pioneered this approach with its Powers of Tau ceremony, and subsequent projects have refined it.

Newer zk-SNARK constructions like PLONK and its variants use a universal and updatable trusted setup, meaning the same setup can be reused for different circuits and additional participants can strengthen the setup over time without starting from scratch. This mitigates the trusted setup concern but does not eliminate it entirely. The fundamental tradeoff remains: smaller, faster proofs in exchange for a one-time trust assumption.

zk-STARKs: no trusted setup, larger proofs

zk-STARK stands for Zero-Knowledge Scalable Transparent Argument of Knowledge. Transparent means no trusted setup is required. The reference strings are generated from publicly verifiable randomness, which eliminates the toxic waste problem entirely. Scalable refers to the fact that proving time grows quasi-linearly with the size of the computation, making STARKs suitable for very large computations.

The tradeoff is proof size. A zk-STARK proof is typically tens to hundreds of kilobytes, compared to a few hundred bytes for a zk-SNARK. On a blockchain where data storage is expensive, this difference matters. Verification time is also somewhat longer for STARKs, though still fast enough for practical use.

StarkWare, the company behind Starknet, has been the primary commercial advocate for zk-STARKs. Their argument is that the transparency property, combined with quantum resistance from relying only on hash functions rather than elliptic curves, makes STARKs the better long term choice even at the cost of larger proofs. Whether quantum computers will actually threaten elliptic curve cryptography within a relevant timeframe is debated, but the conservative security posture appeals to applications where long term robustness matters more than immediate efficiency.

ZK rollups: the scaling application

The most important practical application of zero-knowledge proofs in blockchain today is ZK rollups. A rollup executes transactions off chain, batches them together, generates a zero-knowledge proof that all transactions were valid, and posts just the proof and compressed transaction data to the main chain. The main chain verifies the proof, which is orders of magnitude cheaper than executing every transaction individually.

This architecture allows Ethereum layer 2 networks to process thousands of transactions for the cost of a single proof verification on layer 1. In practice, ZK rollups like those built on Ethereum infrastructure reduce gas costs by 90 percent or more compared to executing the same transactions directly on mainnet.

The major ZK rollup projects in production or late stage development as of mid 2026 include zkSync Era, Scroll, Polygon zkEVM, Linea, and Taiko. Each uses a different proving system and makes different tradeoffs between EVM compatibility, proving speed, and decentralization. zkSync uses a custom virtual machine and PLONK-based proofs. Scroll aims for byte-level EVM equivalence using a zk-SNARK prover. Polygon zkEVM uses a combination of STARK and SNARK proofs in a recursive architecture.

The competition between these projects is driving rapid innovation in proof generation. Proving times have dropped from hours to minutes to seconds over the past two years. Vitalik Buterin’s introduction of the GKR protocol for Ethereum represents another step toward making ZK proof verification a routine operation rather than a computational bottleneck.

Privacy applications beyond rollups

Zero-knowledge proofs were originally developed for privacy, not scalability. Zcash, launched in 2016, was the first major blockchain to use zk-SNARKs for private transactions. In a shielded Zcash transaction, the sender, receiver, and amount are all hidden from public view while the proof guarantees that no coins were created out of thin air and no double spending occurred.

The privacy application extends beyond financial transactions. Zero-knowledge proofs can verify identity attributes without revealing the underlying data. A user could prove they are over 18 without revealing their birth date, prove they are a citizen of a specific country without revealing their passport number, or prove they hold a certain credential without revealing which institution issued it.

Projects like Worldcoin and Polygon ID have implemented ZK-based identity verification systems. Worldcoin uses zero-knowledge proofs to verify that a person has been scanned by their iris scanning device without linking the scan to any specific identity. Ethereum ecosystem projects are increasingly integrating ZK-based identity as a primitive alongside financial transactions.

The privacy use case faces regulatory headwinds. Financial regulators in multiple jurisdictions have expressed concern that fully private transactions could facilitate money laundering, sanctions evasion, and terrorist financing. The tension between privacy as a fundamental right and transparency as a regulatory requirement is one of the defining policy debates in cryptocurrency, and zero-knowledge proofs sit directly at the center of it.

What zero-knowledge proofs do not cover

Zero-knowledge proofs guarantee computational integrity: that a specific computation was performed correctly. They do not guarantee that the inputs to the computation were correct, that the computation was worth performing, or that the system built around the proof is free of bugs.

A ZK rollup can prove that all transactions in a batch were valid according to the rollup’s rules. It cannot prove that the rules themselves are correct. A bug in the rollup’s smart contracts or proving circuit could produce valid proofs for invalid state transitions. Several ZK rollup projects have disclosed and patched critical bugs in their circuits during audits and testnet deployments.

Zero-knowledge proofs also do not eliminate the need for data availability. In a ZK rollup, the proof tells the main chain that the state transition was valid, but users still need access to the underlying transaction data to reconstruct the state and verify that their funds are intact. Without data availability, users must trust the rollup operator, which partially defeats the purpose of the proof.

The computational cost of generating proofs is substantial. While verification is cheap, proof generation requires significant hardware. Running a ZK prover at production scale typically requires servers with hundreds of gigabytes of RAM and specialized hardware accelerators. This cost creates a natural centralizing force in who can afford to run provers, even if the proofs themselves can be verified by anyone.

Practical checks for evaluating ZK projects

When evaluating a project that claims to use zero-knowledge proofs, several questions distinguish serious implementations from marketing.

First, ask whether the proof system has been independently audited. Circuit bugs can create soundness vulnerabilities where invalid proofs are accepted as valid. A project that has not been audited by multiple independent cryptography firms should be treated with caution.

Second, ask whether the proving system uses a trusted setup and, if so, how the ceremony was conducted. A trusted setup with only a small number of participants, or one conducted by a single company without external verification, represents a meaningful trust assumption.

Third, check whether the project publishes its proof verification contracts and whether those contracts have been verified on chain. If verification is happening off chain or through upgradeable proxy contracts controlled by a multisig, the zero-knowledge proofs may not be providing the security guarantees users expect.

Fourth, look at the data availability solution. If the project does not post transaction data on chain or to a credible data availability layer, users cannot independently verify the state and must trust the operator. This is a meaningful departure from the trustlessness that zero-knowledge proofs are supposed to enable.

Frequently asked questions

Disclaimer: This article is for informational purposes only and does not constitute financial, investment, or legal advice. Cryptocurrency investments carry significant risk. Always conduct your own research before making any investment decisions. Information is accurate as of August 1, 2026.

A testnet is a separate blockchain network that mirrors a production chain’s rules and functionality but uses tokens with no monetary value. It is where developers break things, test upgrades, and discover bugs before those bugs can cost anyone real money.

Every piece of software ships with bugs. The question is whether those bugs are discovered in a controlled environment or in production, where they can destroy value. In traditional software development, staging environments and QA processes serve this function. In blockchain, testnets serve the same function but with a critical difference: blockchain bugs are often irreversible.

A smart contract that contains a vulnerability on a testnet loses nothing because the tokens are worthless. The same vulnerability on a mainnet can drain millions of dollars in minutes. The history of decentralized finance is littered with exploits that could have been caught on a testnet if the testing had been more thorough.

This article explains what testnets are, how they work, why they matter for the security of every blockchain protocol, and what their limitations are. If you interact with any blockchain application, the quality of its testnet phase directly affects the safety of your funds.

How testnets work

A testnet runs the same node software as its corresponding mainnet but operates on a separate network with its own genesis block, its own chain of blocks, and its own set of validators or miners. Transactions on a testnet are processed using the same consensus rules, the same virtual machine, and the same transaction format as mainnet transactions. The only fundamental difference is that the tokens have no market value.

This separation is enforced at the network level. Testnet nodes connect to other testnet nodes, not to mainnet nodes. The chain IDs are different, which prevents testnet transactions from being replayed on mainnet and vice versa. When a developer deploys a smart contract to a testnet, that contract exists only on the testnet and has no effect on the mainnet state.

Testnet tokens are distributed through faucets, which are simple web applications that send a small amount of test tokens to any wallet address that requests them. Most faucets impose rate limits to prevent abuse. Some require completing a captcha or connecting a social media account. The tokens have no monetary value by design, though there have been instances where testnet tokens have traded on secondary markets, which defeats their purpose and is generally discouraged by protocol teams.

Developers use testnets to deploy and interact with smart contracts exactly as they would on mainnet. They can test function calls, simulate user interactions, measure gas consumption, and verify that error handling works correctly. Wallet applications, decentralized exchanges, lending protocols, and NFT marketplaces all go through testnet deployment before launching on mainnet.

Types of testnets

Not all testnets serve the same purpose. Public testnets are open to anyone and mirror mainnet conditions as closely as possible. They are used for final stage testing before mainnet deployment and for community members who want to try new features. Ethereum’s Sepolia and Holesky are public testnets. Base’s Beryl testnet is another example of a public testnet used to test protocol upgrades before mainnet deployment.

Private or permissioned testnets are operated by specific development teams and are not open to public participation. These are used for early stage development where the protocol may be unstable or where the team wants to control the testing conditions. Many projects run private testnets for months before opening a public testnet.

Local development networks, sometimes called devnets, run on a developer’s own machine. Tools like Hardhat and Foundry for Ethereum allow developers to spin up a local blockchain instance, deploy contracts, and run tests in seconds without connecting to any external network. These are not true testnets but serve a similar function for unit testing and rapid iteration.

Shadow forks are a newer concept where a testnet replays real mainnet transaction data against a modified version of the protocol. This allows developers to test upgrades against realistic transaction patterns and state sizes rather than the synthetic and often unrealistic conditions of a standard testnet. Ethereum used shadow forking extensively during the preparation for The Merge in 2022.

Why testnet phases matter for protocol upgrades

Major blockchain upgrades follow a predictable lifecycle: specification, implementation, testnet deployment, monitoring, and finally mainnet activation. The testnet phase is where the implementation meets reality. Bugs that were invisible in unit tests become apparent when the code runs on a distributed network with independent operators, network latency, and concurrent transactions.

Ethereum’s Pectra upgrade, which introduced account abstraction and increased blob capacity, was deployed to the Hoodi testnet months before reaching mainnet. During the testnet phase, developers discovered edge cases in the account abstraction implementation that would have caused transaction failures for a subset of users. These were fixed before mainnet deployment.

Cardano’s van Rossem hard fork followed a similar pattern, with the upgrade reaching its public testnet weeks before the mainnet governance vote that activated it. The testnet phase allowed stake pool operators to update their nodes and verify compatibility before the hard fork went live.

The length of the testnet phase varies by the complexity and risk of the upgrade. Simple parameter changes might spend days on a testnet. Fundamental consensus changes like The Merge spent months across multiple testnets. The pressure to move quickly is always present, but the cost of shipping a mainnet bug that could have been caught on a testnet is high enough that most serious protocol teams err on the side of longer testing periods.

The gap between testnet and mainnet

Testnets are valuable but imperfect. Several categories of problems are difficult or impossible to reproduce on a testnet. Economic attacks, where an attacker exploits the relationship between token prices and protocol mechanics, require real economic incentives that do not exist on a testnet. Miner or validator extractable value strategies, front running, and sandwich attacks depend on real financial motivation.

Scale related bugs also often escape testnet detection. A testnet with 100 validators processes transactions differently than a mainnet with 1,000 validators. Network congestion patterns, state bloat, and the behavior of the peer to peer gossip layer under load all change with scale. Some bugs only manifest when the state database exceeds a certain size or when transaction volume spikes above levels that testnets rarely experience.

The social and governance dimensions of blockchain also differ between testnet and mainnet. On a testnet, there are no real stakeholders with financial exposure who might resist an upgrade. The politics of hard fork coordination, which can involve exchanges, wallet providers, major token holders, and application developers, do not exist on a testnet. A protocol change that works perfectly on a testnet can still fail on mainnet if the coordination required to activate it breaks down.

This gap is why many blockchain projects now use incentivized testnets, where participants earn rewards for finding bugs, stress testing the network, or running validators. Robinhood’s chain testnet recorded 4 million transactions in its first week, partly because of incentive programs that attracted real users performing realistic interactions rather than synthetic test scripts.

What testnets do not cover

Testnets do not test economic security. The value of tokens on a testnet is zero, which means rational economic actors behave differently than they would on mainnet. A protocol that appears secure on a testnet may be vulnerable to economic exploits that only become apparent when real money is at stake.

Testnets do not test long term stability. Most testnets are reset periodically, which means issues related to state growth, database performance over time, and the accumulation of edge cases in long running chains are not tested. Some protocols run long lived testnets specifically to catch these issues, but the practice is not universal.

Testnets do not test user behavior. On a testnet, users have no reason to optimize gas usage, rush to complete transactions before a deadline, or engage in arbitrage. The transaction patterns on a testnet are fundamentally different from mainnet patterns, which means performance metrics measured on a testnet may not translate to mainnet conditions.

Practical checks for using testnets

If you are a developer, always deploy to a testnet before mainnet. This sounds obvious but a surprising number of smart contract exploits involve code that was deployed directly to mainnet without adequate testnet coverage. Use automated testing frameworks to run your test suite against a testnet deployment, not just a local node.

If you are a user, check whether the applications you use went through a public testnet phase. Serious projects publish testnet addresses, invite community testing, and often run bug bounty programs during the testnet phase. A project that skips the public testnet phase and launches directly to mainnet is taking a risk with its users’ funds.

When interacting with testnets, use a separate wallet from your mainnet wallet. While testnet transactions cannot affect mainnet, using the same private key on both networks is a bad security practice. If a testnet application is compromised or contains malicious code, having your mainnet private key in the same wallet creates unnecessary risk.

Monitor the testnet phase of upgrades to networks where you hold assets. If a major upgrade encounters problems on a testnet, it may be delayed or modified before mainnet deployment. Understanding the testnet timeline gives you advance notice of potential disruptions or opportunities.

Frequently asked questions

Disclaimer: This article is for informational purposes only and does not constitute financial, investment, or legal advice. Cryptocurrency investments carry significant risk. Always conduct your own research before making any investment decisions. Information is accurate as of August 1, 2026.

Crypto holders used to focus on diversifying their coins. Now, following a $70 million Coldcard exploit, they’re being told to diversify their wallets as well.

On Saturday, Binance founder Changpeng Zhao, known as CZ, asked crypto holders to split their funds across multiple wallets following a major security failure in popular Coldcard hardware devices.

“Even hardware wallets can have bugs. Even old wallets (with long history) can have bugs. How to mitigate? Split your funds in a few wallets maybe? This has a different set of risks. Nothing is 100%. Stay informed. Stay SAFU!,” he said.

On July 30, some bitcoin users discovered that funds from their Coldcard wallets had been stolen in a series of unexpected transactions. The attacker exploited a firmware flaw dating to March 2021 that weakened the randomness used to generate recovery seeds on certain Coldcard models. By reconstructing private keys offline, the attacker was able to drain funds without ever physically accessing the devices.

Initial reports said about 594 BTC, worth $38 million at the time, were drained from around 500 wallet in a 25-minute window. Subsequent analysis by Galaxy Research expanded the scope to 1,082.65 bitcoin, valued at approximately $70 million, drained from 1,196 addresses over about 41 minutes. Many of the affected wallets had sat dormant for years.

Coldcard maker Coinkite has acknowledged the bug, apologized, and released emergency firmware updates. The company has advised users who generated seeds on affected versions to create entirely new seeds on patched devices and carefully migrate funds, noting that simply updating firmware does not secure an already-created vulnerable seed.

The episode has renewed debate over the limits of self-custody. Hardware wallets are widely viewed as one of the strongest options for securing bitcoin offline, yet the Coldcard case shows that even long-established devices can harbor critical flaws that remain undetected for years.

CZ’s suggestion of diversification acknowledges that spreading risk comes with its own practical challenges, including more complex key management.