Bloom Trading Bot Hack: Lessons from the $953K Loss
Bloom users lost $953,000 in 94 seconds. Learn what the attack reveals about trading bot permissions, dormant wallets and practical crypto security.

The Bloom Bot Hack Shows How Fast Crypto Wallet Risk Can Add Up
A crypto trading bot can make fast-moving markets easier to handle. It can also quietly shift security risk onto your wallet - so much so that the danger can fade from your mind once you stop using it. The reported attack on Bloom makes that trade-off hard to ignore: according to blockchain analytics company Bitquery, $953,000 was drained from 48 wallets belonging to nine traders in just 94 seconds.
Bloom said it would reimburse the affected traders in full. The platform blamed a remote code execution vulnerability in a third-party module and said no private keys were accessed or compromised. Bitquery, meanwhile, reported that each drain was a Solana transfer signed with the private key tied to an affected wallet. Those details line up on different parts of the story, but they don't, by themselves, explain exactly how the signing process was exposed - or how it was used.
The main takeaway goes beyond one platform: if a bot can trade on your behalf, its security effectively becomes part of your wallet's security. Below is what was reported, what the "signed transfer" detail can - and can't - tell you, why old bot connections can still matter, and what users and operators should do next.
What happened in the Bloom trading bot attack?
Bitquery reported that attackers drained $953,000 from 48 cryptocurrency wallets connected to the Telegram trading bot Bloom. The transfers happened over 94 seconds and affected nine traders. Bitquery said the stolen funds moved through Solana transfers signed with the private keys associated with the affected wallets.
Bloom later said the incident resulted from a remote code execution vulnerability in a third-party module. It also said no private keys were accessed or compromised, and it pledged to reimburse all affected traders in full. That's a promise to compensate users - but the source report doesn't confirm that reimbursements have already been completed.
The timeline matters, but it is not the whole story
Losing nearly $1 million in 94 seconds definitely points to a speed problem. Once a system can initiate or authorize transactions at scale, there's often very little time for people to notice something odd and respond.
But the transaction window is just the visible end of a longer security chain. The better questions are: what part of the software path was involved, what authority that path had, and what controls are going to prevent this from happening again.
Bitquery also said multiple wallets were involved for a small group of traders. That's a practical risk pattern: people sometimes connect several wallets to one bot or workflow, treating each connection like an independent choice. In reality, a shared service or component can create shared exposure across accounts. The source report doesn't say how the 48 wallets were configured or whether they shared a particular setup, so it would be a guess to pin down the exact mechanism.
What is confirmed - and what remains unclear
What we can say with confidence is limited to what the sources report: the amounts involved, how many wallets and traders were affected, Bloom's reimbursement pledge, and Bloom's stated explanation pointing to a third-party module. The precise technical sequence isn't confirmed publicly.
In particular, Bloom's claim that private keys were not accessed is about what the company believes happened on its side. Bitquery's observation about signed transfers is about what shows up on-chain. Those are different kinds of evidence.
A signed transfer matters because it shows that a transaction received valid authorization. It doesn't automatically prove that an attacker obtained a raw private key. It's possible the signing was performed in a system where the key wasn't extracted. But based on the information available so far, the reporting doesn't establish how the signing process actually worked in this incident. Until more technical detail is published, the careful conclusion is narrow: funds moved via signed transactions; Bloom cited a remote code execution vulnerability in a third-party module; and the public reporting hasn't fully tied those together in a way we can verify.
What does a signed transfer tell us about private keys?
Blockchains treat a transaction signature as proof that the relevant key authorized it. That design is central to how these networks work: the network can verify the signature without needing to know who - or what software - initiated the transaction.
But an on-chain record of a valid signature doesn't tell you where the key was stored, who controlled the signing workflow, or whether the key itself was copied. It tells you the authorization was valid, not how it was produced.
That distinction matters when people try to interpret security claims. "The transaction was signed by the wallet" and "the attacker stole the wallet's private key" are not the same thing. The first is an on-chain authorization fact. The second is a claim about how the attacker gained control.
A compromised application, signing service, device, or software component could affect transaction authorization without any public evidence showing that a raw key was extracted. Which explanation fits Bloom's case is still uncertain from the information available.
Treat signing authority as the asset at risk
For users, the practical issue isn't only whether a seed phrase or private-key file was copied. The bigger question is whether an application or service can cause transactions to be signed on your behalf - and what limits exist around that authority.
If a bot can trade for you, you've delegated part of the wallet's day-to-day operating process, even if you don't think of it as "giving away" the key.
This delegation can be convenient. You don't have to approve every routine action manually. The trade-off is that your security now depends on more than your own device and habits. It can include the bot's code, its dependencies, its infrastructure, and how it handles transaction signing. A vulnerability in one layer can still affect users who never directly touched that vulnerable component.
Avoid over-reading the public evidence
A blockchain explorer can show which addresses sent or received funds and when. It can't necessarily show the software path that produced a signature.
Similarly, a platform statement may describe what investigators believe happened, but a brief incident update isn't the same as a full technical postmortem.
When you read an incident like this, separate three questions:
- What happened on-chain? Which wallets transferred assets, and when?
- What does the platform say caused it? In Bloom's case, remote code execution in a third-party module.
- What evidence explains how the cause led to authorized transactions? The public source doesn't provide that full technical chain.
Keeping those questions separate prevents two common mistakes: treating every signed transfer as proof that a private key was stolen, or treating "no keys were compromised" as proof that key-related risk didn't exist. Either way, the security outcome matters - especially while the exact mechanism is still being investigated.
Why can a trading bot remain a risk after you stop using it?
Bitquery said five of the wallets drained in the Bloom attack had been inactive on the bot since the first half of 2025. That's a useful warning about permissions: stopping a service's use doesn't always mean every relevant connection, key, or account has been removed. The source report doesn't define what "inactive" means technically for those wallets, so it can't confirm whether any permission remained active.
Even if the wallets weren't actively used, it's worth reviewing dormant access. People tend to remember when they started using a tool - not every authorization and credential created along the way.
This same pattern shows up in ordinary software too. A former integration can keep an API key. A service account can exist after a project ends. A wallet can remain attached to a trading workflow long after someone stops opening the bot. In each case, the risk comes from a mismatch between what users think is true - "I no longer use this" - and what the system is actually configured to do.
A bot is a dependency, not just an interface
Telegram is the interface users see, but the bot's ability to act depends on software and infrastructure behind that interface. Bloom's explanation points to a third-party module, which is a reminder that a product's security boundary can extend beyond its own code. If a dependency is vulnerable, users can be affected even if they never see that component and can't judge its quality directly.
This doesn't mean dependencies are inherently unsafe. Most modern software relies on shared libraries and external services, and rewriting everything in-house is often less secure and harder to maintain.
What matters is how dependencies are managed: who can access sensitive operations, how damage is limited if something fails, and how abnormal activity is detected and contained.
For a trading bot, this is especially important. Both a routine action and a malicious transaction can look like "valid activity" to the network if they carry valid authorization. So user protection depends partly on the limits and monitoring around transaction signing - not just on whether the app looks like it's behaving normally.
Build a simple inventory of wallet connections
You don't need a complex audit to reduce forgotten exposure. Start by listing the wallets you connected to trading bots, exchanges, browser extensions, and other crypto tools. For each one, note whether it's still active, what assets it holds, and what permissions or credentials are configured. If you can't tell what's still connected, treat that as an open question rather than assuming the connection expired.
A review like this can be straightforward:
- Which wallets have been used with automated trading tools?
- Are any of them still holding balances you wouldn't want exposed to a software failure?
- Is there a documented way to remove access, rotate credentials, or stop signing?
- Have you reviewed old wallets that have been inactive for months?
This isn't an argument that every dormant wallet is compromised. It's about making exposure visible. The Bloom report shows why "I stopped using the bot" isn't a complete security check: several affected wallets hadn't been active on the service for months before the reported attack.
How should crypto users and bot operators respond?
Users and operators have different responsibilities. A user can limit the value exposed and remove obsolete connections. The operator has to investigate the vulnerable component, explain the scope of impact, and show what security controls are changing. One side can't replace the other.
For users: contain first, investigate second
If you think a wallet might be involved in an exploit, prioritize containment over trying to reverse-engineer the vulnerability yourself. Stop using the potentially affected wallet for new activity while you assess it. If it still holds funds, consider moving them to a fresh wallet whose credentials weren't used with the service.
For meaningful balances, double-check the destination and the transaction details before signing anything. Rushing can turn incident response into a second loss.
Then review the permissions and credentials associated with the wallet. Exact steps differ by chain and by the type of access granted. Use the relevant wallet and service documentation, and use a trusted wallet interface to inspect or remove authorizations where possible. Don't assume that deleting a Telegram chat or uninstalling an app removes every kind of access. If you can't figure out what the bot was allowed to do, ask the platform for specific instructions - and keep transaction records so you can verify what happened on your own.
A few operating rules can help keep future exposure under control:
- Keep long-term holdings in wallets separate from those used for automated trading.
- Fund a trading wallet only with the amount needed for that activity.
- Review connected tools and old wallets periodically, not only after an incident.
- Don't share a seed phrase in response to support requests or recovery offers.
- Treat reimbursement as separate from wallet security: a refund doesn't remove access or prevent another incident.
These steps come with trade-offs. Using a separate wallet adds setup and transfer steps, and keeping balances small can make trading less convenient. That friction is deliberate - it limits how much a compromised workflow can reach.
For operators: make the security boundary visible
A useful post-incident report should explain the affected systems, the timeline, the scope of impacted wallets, the role of the third-party module, and what remediation was actually done. It should separate confirmed findings from open questions. That level of clarity is more useful than a broad reassurance because users need enough information to decide whether they should move funds, stop using the service, or take additional steps.
Operators should also make authorization and recovery clear before anything goes wrong. Users need to know what the bot can do, how to disconnect it, what happens to credentials and signing capability after disconnection, and which actions require renewed approval. Ideally, that belongs in the normal product flow - not in some emergency scramble during a crisis.
Bloom's pledge to reimburse affected traders addresses the financial loss reported in this incident. It doesn't, by itself, answer questions about the vulnerable module, the signing pathway, or the controls meant to reduce future exposure. Users should look for follow-up on those points, and treat reimbursement and technical remediation as separate parts of the response.
Conclusion
The Bloom incident is a reminder that automated trading can push security responsibility beyond the wallet interface. Even if a service feels convenient, its code, infrastructure, and dependencies can all feed into the path that authorizes transactions. That remains true even if the exact exploit mechanism hasn't been fully explained publicly yet.
For users, the practical response is to inventory bot-connected wallets, limit the balances exposed to automation, and verify what access remains after the service is no longer in use. For operators, a reimbursement pledge matters - but users also need a clear technical account and durable changes to the authorization boundary. Treat both as part of the incident response.