Subscribe
Share
blog post background
Trending → →

Crypto wallet testing: What it takes when every bug can cost real money

By Siarhei Huzau, Senior QA Engineer at ITRex; hands-on across AI-driven quality assurance and crypto wallet testing (Ethereum, Polygon, Tron, and Bitcoin)
Published on

TL;DR

  • A crypto wallet is the one fintech product where a bug can’t be refunded. Confirmed blockchain transactions are final, so a defect that sends funds to the wrong address or network turns into a permanent loss for the user and a trust problem for your brand.
  • Attackers have noticed. Chainalysis counted 158,000 personal wallet compromises affecting at least 80,000 victims in 2025, and personal wallets’ share of stolen crypto value jumped from 7.3% in 2022 to 44% in 2024.
  • Regulators have noticed, too. The EU’s MiCA transition period ended on July 1, 2026, and crypto-asset service providers authorized under MiCA, custodial wallet providers included, must run digital operational resilience testing under DORA. In the US, the GENIUS Act for payment stablecoins takes effect no later than January 18, 2027.
  • A standard mobile regression suite won’t catch most wallet bugs. A single tap on Send can touch the app, a back end, RPC nodes, third-party swap providers, and the blockchain itself, and each layer fails in its own way.
  • Every token, network, and operation combination is a separate test context. “Send USDT on Tron” and “Send USDT on Ethereum” have different address rules, fees, and failure modes, so each new network your product adds multiplies the regression scope.
  • Over the past year, ITRex QA engineers have tested three very different wallets, including a product for one of the largest players in the crypto market. Below, we share our layered testing approach, three anonymized case studies, and a condensed version of our 85-point wallet QA checklist.

What’s the true cost of a bug in a crypto wallet?

In most apps, a payment bug ends with a refund and an apology. In a crypto wallet, it often ends with money that no one can return. The blockchain doesn’t have a chargeback button.

The threat picture makes the stakes sharper. According to Chainalysis, crypto theft reached $3.41 billion between January and early December 2025, up from $3.38 billion in 2024. More telling for wallet builders, personal wallet compromises reached 158,000 cases, nearly triple the 54,000 recorded in 2022, while the total value stolen from individuals fell to $713 million. Attackers are going after more users with smaller balances, and the wallet app is their main way in.

For the company behind the wallet, the user’s loss is only the first cost. A transfer that lands on the wrong network becomes a support ticket nobody can resolve, then a public complaint, then a reason for the next user to choose a competitor. If you run a custodial wallet in the EU, there’s a regulatory cost as well. Since July 1, 2026, crypto-asset service providers need MiCA authorization to serve EU clients, and once authorized, they fall under DORA, which requires a documented digital operational resilience testing program. Non-custodial wallets mostly sit outside MiCA’s scope, but your exchange partners and investors will still ask how you know if the money paths work.

That gap between “the app works” and “the app is safe to hold real money” is a testing problem, and a standard mobile regression suite won’t close it. To close it, you need a QA team that understands how keys, networks, fees, and confirmations work, treats on-chain data as the source of truth, and interprets every status on screen as a claim to verify.

Why do crypto wallets break traditional QA playbooks?

A wallet looks like a mobile banking app, but it plays by four rules a banking app doesn’t: payments are final, the same token lives on several networks, transactions settle asynchronously, and a 12-word phrase is the entire account. Each rule moves risk to a place that a standard test plan does not consider.

Rule #1: Every transaction is final

Once a transaction is signed and confirmed on-chain, nobody can cancel or edit it. That moves the weight of testing to everything that happens before the user taps Confirm—address validation, network selection, balance and fee checks, and protection against a double tap that sends the same payment twice. For your budget, that means the cheapest place to catch a wallet bug is before the signature. After it, the fix is a code change, and the user’s loss is permanent.

Rule #2: Tokens & networks are two different things

The same token can exist on several blockchains. USDT, for example, runs on Ethereum, Polygon, and Tron, each with its own address rules, fee model, and native asset for paying fees. Ethereum and Polygon share an address format, so a user can send USDT over the wrong network without any visible warning, and the recipient’s exchange may never credit it.

For QA, this peculiarity transforms one feature into a matrix where each supported token, network, and operation is a separate test context. A wallet with 5 tokens on 4 networks and 4 operations (send, receive, buy, swap) already has up to 80 combinations, and every network your product team adds multiplies that number.

Rule #3: Transactions are asynchronous by nature

A transaction moves from created to signed, submitted, pending, and confirmed, or ends as failed or rejected. Statuses aren’t always linear; the recipient’s wallet sees the payment later than the sender’s, and an error on screen doesn’t cancel what has already reached the network. The app must resync after crashes, restarts, and connection drops without losing or duplicating records. For your support team, every status that fails to sync is a “where is my money?” ticket.

Rule #4: The seed phrase is the wallet

In a non-custodial wallet, 12 or 24 words restore full control over the user’s funds on any device. If that phrase lands in a log file, an analytics event, a crash report, a screenshot, or a QR code, the user’s money is effectively public. That’s why our security testing hunts for observable exposure first and complements the penetration tests a specialized security team runs.

The practical consequence: testing a wallet against its UI alone is like auditing a bank by reading its mobile app. You need to look at what actually happened.

How does ITRex test crypto wallets?

We test crypto wallets in layers and trust the chain. Every operation is traced from the app screen down to on-chain data, and every bug report names the layer where the failure lives. That habit matters because in a wallet project, the mobile app, the back end, and the swap provider integration are often owned by different teams, and sometimes by different companies.

A wallet bug can live in any of five layers; the explorer settles it

Wallet app
Shows data, signs transactions on the device
Fails: wrong balance, amount, status, or fee shown

↓

Back end
Token and network catalog, quotes, history, statuses
Fails: wrong catalog, bad quotes, out-of-sync status

quotes
⟶

Swap and bridge providers
Route conversions across assets
Fails: unsupported route, limits, expired quotes

↓

RPC / node
Reads balances and tx state, broadcasts signed tx
Fails: timeouts, unavailable node, stale data

↓

Blockchain
Records the transaction in a block
Fails: rejected or reverted tx, out of gas

TX hash
⟶

Blockchain explorer
Etherscan, Polygonscan, Tronscan
Independent source of truth

A wallet bug can live in any of five layers. A blockchain explorer such as Etherscan gives QA an independent record to check each layer against.

Three principles follow from this picture:

  1. Start with the context. Before any test, we pin down the token, the network, and the amount. Decimals alone can break a flow. Every token has a fixed number of decimal places that defines its smallest unit: Bitcoin has 8, ETH has 18, and USDT has 6 on Ethereum but 18 on BNB Chain. If the app converts between these units incorrectly, or a screen built for dollars and cents rounds the result to two decimals, the amount the user sees stops matching the amount the network moves.

  2. Follow the evidence path. We trace each operation through every layer it touches. That includes the app, the back end’s responses, and the RPC calls the wallet sends to a blockchain node to read balances and broadcast transactions. It also includes the data exchanged with swap providers and, finally, the record on the blockchain itself. Proxy tools like Charles sit between the app and the internet and show every request the app sends, including whether anything secret, such as a seed phrase, leaves the device.

  3. Let the explorer settle disputes. Every transaction gets a hash, a unique ID that anyone can look up in a public blockchain explorer such as Etherscan (Ethereum) or Polygonscan (Polygon). The explorer shows the transaction’s real status, amount, fee, sender, and recipient, independently of the wallet’s own app and servers. If the app says Pending while Polygonscan says Success, we’ve got a status sync bug with hard evidence attached. If the app says Completed while the explorer still shows Pending, the app marks the payment final before the network has confirmed it. In every check, we compare like with like: the app’s amount with the on-chain amount and the app’s fee with the on-chain fee.

The result is a bug report that reads “history shows Pending, the explorer shows Success for this hash, the back end returns pending,” instead of “payment stuck.” The first goes straight to the team that can fix it. The second bounces between teams, and every bounce adds days to your release.

What did we learn from testing three crypto wallets?

Why do so many wallets exist? Because each one serves a different business model, and each model shifts where the risk sits. Here are three projects from our fintech software development and blockchain development work, anonymized to respect client confidentiality, with a note on where the business risk sat in each.

Case study #1: A city-wide crypto payment network

Crypto wallet testing
QR code payment stand with a damaged corner, representing crypto wallet testing of QR payments, including blurred, cropped, and damaged codes

Challenge

A European municipality wanted to connect residents with local businesses that accept crypto: restaurants, shops, pharmacies, and services. The product consists of two mobile apps, one for consumers and one for merchants, plus an admin panel where city staff verify and onboard merchants. Consumers can sign up without identity checks but unlock cashback of up to 10% per purchase only after verification. Cashback is paid in a dedicated network token that residents can spend with other merchants.

The QA risk was concentrated in two places:

  • Payments between consumers and merchants run on QR codes, so a single decoding error could send money to the wrong address or for the wrong amount.

  • The whole product was being built on testnet (Ethereum’s Sepolia) ahead of a mainnet launch, where test tokens become real money.

For the city, a single misrouted payment would have hurt residents’ trust in the whole program, well beyond the app where it happened.

Solution

We tested the full QR data path along with the scanner: what the merchant’s app encodes (address, network, token, exact amount), how the consumer’s app decodes it, and whether every field lands in the payment form intact. Negative scenarios covered blurred, cropped, and damaged codes; QR codes for a different network; invalid amounts; revoked camera permissions; and codes that don’t fit small screens. We also built seed phrase recovery coverage: wrong word counts, words outside the 2,048-word BIP-39 list, swapped order, checksum failures, stray spaces, and interrupted recovery.

Results

  • The QR payment and seed phrase recovery flows entered mainnet preparation with regression coverage for seven QR failure scenarios and six recovery failure scenarios, which the team can rerun before each release.

  • The team also had a dedicated switch-over checklist for the mainnet: the network itself changes along with its label; balances, history, and fees belong to the right network; recipient addresses validate; and the first real transactions are verified in the mainnet explorer, amount and fee included.

Case study #2: A multi-network stablecoin wallet

Crypto wallet testing_case study2
Smartphone mounted in a QA testing clamp, representing crypto wallet QA for a multi-network stablecoin wallet on Ethereum, Polygon, Tron, and Bitcoin.

Challenge

A major digital asset company needed a non-custodial mobile wallet that makes stablecoins and Bitcoin usable for people who don’t want to learn how blockchains work. Users send, receive, buy, and convert assets across Ethereum, Polygon, Tron, and Bitcoin. Conversions run through third-party route aggregators and cross-chain providers, each supporting its own set of tokens, networks, and amount limits.

The hardest part was the convert flow: one tap on Convert could involve several networks, several providers, and several on-chain transactions, each with its own fees. For the client, the risk was reputational. Users who don’t understand blockchains blame the brand for every fee they didn’t expect, whatever caused it.

Solution

We built test coverage around the token, network, and operation matrix and checked provider documentation and live API responses for supported routes and limits, rather than relying on assumptions. Fee testing covered every component a user may pay without seeing it as a separate line: network fee, provider fee, protocol fee, exchange fee, relayer cost (what a third-party service charges for submitting the transaction on the user’s behalf), and spread (the gap between the market rate and the rate the user actually gets). On networks like Ethereum and Polygon, the network fee is calculated in gas, a unit that measures how much computation a transaction needs, multiplied by a gas price that rises and falls with demand. There, we compared the app’s fee estimates with the gas each transaction actually used and the gas price it actually paid, as recorded on-chain. Quote handling got special attention: we waited for quotes to refresh on the confirmation screen and verified that the last quote shown was the one executed.

One honest note: much of this testing happens on mainnet with real funds, because provider routes and real fee behavior can’t be fully reproduced on testnet. We ran stress checks in the evening, when network fees spike, which is precisely when users get surprised and edge cases surface. If you’re planning a similar product, budget for this phase: a small mainnet test float and a few evening test windows cost far less than the first support escalation.

Results

  • Every operation in the wallet (send, receive, buy, and convert across Ethereum, Polygon, Tron, and Bitcoin) is now verified end to end, from the app screen to on-chain data, with a hash for each step of multi-stage conversions.

  • Fee checks cover all six components a user can pay, so a gap between the estimated and the actual fee shows up as a defect tied to a specific fee component and layer.

  • Mismatches between the app’s status and the explorer’s surface the same way, as layer-specific defects with the transaction hash attached.

Case study #3: A creator-tipping wallet

Glass tip jar with one coin
Glass tip jar with a single small coin, representing crypto wallet software testing for micro-payments, decimal precision, and fees in a creator-tipping wallet.

Challenge

A product team built a non-custodial wallet whose core purpose is letting fans send small crypto donations to content creators. Small payments expose the weakest spots of any wallet: fractional amounts with up to 8 or 18 decimal places, fiat equivalents (the value in dollars or euros the app shows next to the crypto amount) that change between sending and receiving, and fees that can eat a large share of a tiny transfer. A fan who sends a $2 tip expects the creator to see roughly $2, and every cent lost to rounding or fees shows up in reviews.

Solution

We focused on amount handling and resilience: precision and rounding for minimal amounts, fiat conversion against public rate sources, Max amount net of fees, and behavior when the network drops or the app goes to background or is killed mid-transaction. Buy, sell, and swap flows through external providers were covered for supported pairs, limits, and error handling.

Results

  • The product team got a regression baseline for the money paths that matter most in a micro-payment product: what the fan sends, what the creator receives, and what happens when a connection breaks in between.

  • Amount handling is now tested down to the smallest unit for amounts with up to 8 or 18 decimal places, including rounding, fiat conversion, and the Max amount net of fees.

  • Interrupted transfers are covered in three scenarios: a dropped network connection, the app moving to the background, and the app being killed mid-transaction.

What areas should a crypto wallet test strategy cover?

The three projects above looked nothing alike: a municipal payment network, a multi-network stablecoin wallet, and a micro-tipping app. Yet when we compared where the risk sat in each, the same eight areas surfaced every time. We compiled an internal checklist of 85 checks that we use to scope every new wallet project. The table below condenses it to one line per area and adds a column for budget conversations: what each gap costs you if it’s detected in production.

You can use the table in two different ways. If you’re building a wallet, compare each area to your token, network, and operation matrix to determine where the most coverage is required. If your wallet is already live, begin with any areas that your team cannot confidently vouch for.

Area What we verify What it costs you if missed
Networks & environments Only supported networks are offered; the selected network holds through the whole flow; testnet and mainnet data never mix Funds sent on an unsupported network; test balances shown as real
Wallet creation & recovery Seed phrase follows the standard; restore reproduces the same addresses on any device; invalid phrases are rejected Users locked out of their funds after a reinstall or new phone
Addresses & QR codes Format and checksum validation for typed, pasted, and scanned input; the full QR encode-decode path Payments to the wrong address or for the wrong amount
Sending Pre-sign validation, single transaction on double tap, correct final state after timeouts, crashes, and lost connections Duplicate payments and refund requests you can’t honor
Fees & quotes Fee components and estimates, quote refresh and expiry, provider limits, estimate vs. actual on-chain Users charged more than the quote they approved
Statuses & history Correct transitions, resync without duplicates, consistency between history, details, and the explorer Support load from transactions stuck in Pending
Balances & conversions Fresh balances despite RPC failures, accurate fiat equivalents, supported routes only Wrong balances, failed swaps, and churn
Security & privacy No secrets in logs, analytics, traffic, or screenshots; clipboard clearing; biometrics; app switcher masking; push content; hide-balance mode Seed phrase exposure, stolen funds, and press coverage you don’t want
Table of a crypto wallet test strategy: eight risk areas (networks, wallet recovery, addresses and QR codes, sending, fees, statuses, balances, and security), with what QA verifies in each and what each gap costs if missed.

Two parts of this checklist are often underestimated: the testnet-to-mainnet migration and test data hygiene.

The migration looks like a configuration change, yet almost everything in the table has to be rechecked on the new network: balances, history, fees, address validation, and the first real transactions in the mainnet explorer. In our municipal payment project, the switch-over got its own checklist, and we’d recommend the same for any wallet: plan it as a separate release, with a small amount of real funds set aside for verification.

As for test data, security testing calls for wallets created for QA alone. A real seed phrase or private key pasted into a bug tracker or group chat is exposed to everyone with access to that tool and to anyone who breaches it. Decide where test wallets live and who can open them before the first test run.

Across the three wallets in this article, the riskiest defects came from four places: operations running on the wrong network, seed phrases exposed outside the app, QR codes decoded differently from how they were encoded, and app statuses that didn’t match the chain. Start your test strategy there, then work through the rest of the checklist above.

FAQs

  • How to set up a crypto wallet QA strategy?

    A crypto wallet QA strategy starts with a list of every token, network, and operation the wallet supports. The QA team then ranks these combinations by how much money and how many users each one handles. For example, USDT transfers on the network most of your users choose will rank higher than a swap pair that sees a few trades a week. The top-ranked combinations get the most thorough testing, and the eight risk areas from the checklist above show what that testing should cover. Finally, the strategy sets the rules for stopping a release. If testers find a defect that can send funds to the wrong place, charge a user twice, or expose a private key, the release waits until it’s fixed, even if every other test passes.

  • How to test crypto wallet software before public launch?

    Most pre-launch testing happens on testnet, and the final round happens on mainnet with small amounts of real money. A testnet is a copy of a blockchain where tokens have no market value. Sepolia, for example, is Ethereum’s main testnet, so your team can run as many transfers and failure scenarios as it needs for free. The catch is that testnet and mainnet keep separate addresses, balances, history, and fees, and some swap provider routes and real fee spikes exist only on mainnet. That is why we treat the switch to mainnet as a separate release, complete with its own checklist, and examine the first real transactions in a mainnet explorer, including the amount and fees.

  • How does end-to-end software testing differ for custodial & non-custodial wallets?

    The answer depends on who holds the private keys, the secret codes that control the funds. In a non-custodial wallet, your users hold them, so most of the risk sits on their devices. Testing there focuses on seed phrase creation and recovery, encrypted key storage, and transaction signing. In a custodial wallet, your company holds the keys, and the risk moves to your back end: withdrawal approvals, admin permissions, KYC (know your customer) checks, transaction monitoring, and reconciliation, which confirms that internal balances match what the blockchain shows. Some wallets split control between the user and the provider through MPC (multi-party computation) or multisig, where a transaction needs several signatures. These wallets need both sets of tests, plus one more: what happens when one of the key holders is unavailable.

  • How should manual and automated testing be split for crypto wallets?

    You’ll get the best return by automating the checks that repeat with every release and keeping people on anything that depends on mainnet, third-party providers, or screens that still change. Automation works well for API contract tests, which confirm that your back end still returns what the app expects, and for regression runs across your token, network, and operation matrix. These runs can use testnet or a local fork, a private copy of a blockchain that tools like Anvil and Hardhat can create. Manual testers, in turn, handle mainnet verification with real funds, swap routes through external providers, and QR payments on physical phones. If your designers are still reworking screens every sprint, UI automation will cost you more in script maintenance than it saves, so it usually pays to wait until the design settles.

  • What should a continuous integration QA pipeline for crypto wallet releases include?

    A good continuous integration (CI) pipeline for wallet releases performs quick checks on every code change, runs slower suites prior to each release, and prevents any builds that disrupt a money path. The quick checks cover address format, checksum validation, and amount handling to decimal places, all of which tend to break quietly when shared code is edited. The slower suites run nightly or before a release and include an automated scan of test logs and analytics events for anything resembling a seed phrase or private key. However, the pipeline cannot verify mainnet behavior. A person is still required to do it, so the pipeline’s final step marks a build as ready for mainnet checks rather than shipping it.

  • How do you run performance & load QA testing for crypto wallet applications?

    You can’t load test a public blockchain, but you can load test everything your company runs or pays for around it. That includes your back end, the indexer (the service that turns raw blockchain data into the transaction history users see), your quote and pricing APIs, and your RPC provider, the service that connects your app to blockchain nodes and usually caps how many requests you can send per second. Network congestion deserves its own scenarios. When fees spike and confirmations slow down, users retry, refresh, and write to support all at once. In our stablecoin wallet project, evening test runs during peak fees surfaced edge cases that daytime runs never did.

  • What do penetration testing & security audits for crypto wallets involve?

    Penetration testing and security audits look for vulnerabilities an attacker could exploit in your app, your back end, and the way you handle keys. Specialized security engineers usually run them, often against the OWASP Mobile Application Security Verification Standard (MASVS), an industry checklist for mobile app security. Functional QA covers a more observable layer: whether seed phrases or keys show up in logs, analytics events, crash reports, network traffic, or screenshots, and whether biometrics, the app switcher, and push notifications keep sensitive data hidden. Most wallets need both, so be wary of any vendor that offers one as a substitute for the other.

  • How to test crypto wallets for smart contract risks?

    Wallet QA tests how your app interacts with smart contracts, while the contract code itself needs a separate audit. On the app side, testers check four things. First, token approvals should request only the amount a transaction needs, since an unlimited approval lets a compromised contract drain the user’s entire balance. Second, the confirmation screen should explain in plain words what the user is signing. Third, the app should be able to handle reverted (failed) contract calls without losing track of the transaction. Fourth, it should interact only with verified contract addresses. Contract audits are a different job: auditors combine manual code review with static analysis tools such as Slither and fuzzing tools such as Foundry or Echidna, which hit the contract with large volumes of random inputs to expose edge cases. If your product deploys its own contracts, budget for that audit separately, because a QA team that claims to cover it is overselling.

  • How to validate crypto wallet software for regulatory compliance?

    Testing can’t make a wallet compliant, but it can prove that your compliance logic works and give your compliance team the evidence regulators ask for. In practice, testers verify rules such as KYC gating, transfer limits, and sanctions screening. In our municipal payment network, for example, cashback unlocks only after a user passes identity verification, which is precisely the kind of rule testers need to confirm. In the EU, DORA requires crypto-asset service providers authorized under MiCA to run a digital operational resilience testing program, and your documented test plans, results, and fixes feed straight into it. In the US, the GENIUS Act mainly covers payment stablecoin issuers and takes effect no later than January 18, 2027. Your legal team should confirm which of these rules apply to your product.

  • How to choose a dedicated crypto wallet QA team?

    The right crypto wallet QA team verifies results on the blockchain itself, and the quickest way to check is to ask for a sample bug report. A strong report names the layer where the failure happened (app, back end, RPC node, provider, or chain) and includes a transaction hash, a unique ID anyone can look up in a public blockchain explorer. It’s also worth asking which chains and providers the team has tested before, how they keep test seed phrases out of bug trackers and chats, and whether they can work with your existing test frameworks. Finally, pay attention to what they don’t try to sell you. A team that suggests holding off on automation until your flows are stable is looking after your budget.

TABLE OF CONTENTS
What’s the true cost of a bug in a crypto wallet?Why do crypto wallets break traditional QA playbooks?Rule #1: Every transaction is finalRule #2: Tokens & networks are two different thingsRule #3: Transactions are asynchronous by natureRule #4: The seed phrase is the walletHow does ITRex test crypto wallets?What did we learn from testing three crypto wallets?Case study #1: A city-wide crypto payment networkCase study #2: A multi-network stablecoin walletCase study #3: A creator-tipping walletWhat areas should a crypto wallet test strategy cover?FAQs
Contact ITRex
Contact us
background banner
Background desktop

Building or scaling a crypto wallet? Talk to ITRex’s QA engineers about reviewing your wallet testing strategy. We’ll map your token, network, and operation matrix, show you where the gaps are, and tell you which checks are worth automating and which aren’t.