The same attacker has been linked to security incidents at Fetch.ai and NuNet involving approximately $2 million in combined crypto assets, with researchers tracing the Fetch.ai breach to a leaked signing key and an unusually weak authorization design inside its Ethereum token-conversion contract.
Blockchain security firm Blockaid linked the two incidents through the attacker wallet, which received approximately 8.7 million FET drained from Fetch.ai and was also the recipient of an unauthorized mint of roughly 408.5 million NuNet tokens.
The FET was worth approximately $1.53 million to $1.56 million at the time of the attack, while the NTX mint was valued at roughly $452,000 to $463,000. Combined activity associated with the wallet therefore reached about $2.01 million.
SlowMist’s subsequent technical analysis provides a much clearer picture of what went wrong on the Fetch.ai side.
The vulnerable contract was TokenConversionManagerV3, an Ethereum-based converter used in the Fetch.ai ecosystem. According to SlowMist, its conversionIn() function relied on a valid ECDSA signature from a single externally owned account as its sole authorization check.
That became critical when the private key belonging to the authorized signer was leaked.
Rather than having to find a conventional smart-contract exploit, the attacker could use the compromised private key to generate a fresh, cryptographically valid authorization message for an address they controlled. The contract accepted the signature as legitimate.
Two additional safeguards that could have limited the damage were missing.
SlowMist found that conversionIn() did not contain the checkLimits(amount) modifier used by the contract’s conversionOut() function. It also did not independently verify an on-chain burn or lock event proving that the tokens being claimed through the converter corresponded with assets legitimately removed elsewhere.
With the signature acting as the primary gatekeeper, possession of the signing key was effectively enough to authorize the conversion. The attacker used it to drain the converter’s remaining FET balance in a single call.
The incident is another example of why a stolen private key can be as dangerous as a smart-contract vulnerability. Ostium suffered a much larger loss earlier this year after compromise of an off-chain signing key gave an attacker access to protocol funds despite the underlying smart contracts functioning as designed.
There are similarities with the more recent ApeX incident as well. ApeX said an attacker gained access to a key stored on a former employee’s device, leading Indonesian exchange INDODAX to freeze APEX deposits and withdrawals while the incident was investigated.
NuNet’s part of the latest attack appears different.
Blockaid said the wallet associated with the Fetch.ai theft also received approximately 408.5 million newly minted NTX from NuNet’s deployer account. That common destination provides an on-chain link between the incidents and strongly indicates the same actor was involved.
It does not, however, establish that Fetch.ai’s leaked authorizer key was also responsible for the unauthorized NuNet mint. The precise compromise path on the NuNet side has not been established publicly to the same degree as the Fetch.ai converter failure.
PeckShield later tracked the attacker converting stolen assets into approximately 546.36 ETH, worth around $1.44 million at the time of its update.
The market impact was particularly severe for NuNet. NTX fell roughly 65% to 70% after the incident and reached an all-time low around $0.000328. FET suffered a much smaller decline of roughly 5% during the comparable period, while the broader cryptocurrency market was also under pressure.
Fetch.ai has since released preliminary analysis of the incident. According to a summary of its investigation, the project traced the attack from the compromised signature key through the movement of funds into wallets used by the attacker. Fetch.ai and SingularityNET have also reportedly deactivated affected wallets and smart contracts.
The investigation remains ongoing, and Fetch.ai has emphasized that its initial analysis is not final.
The incident adds to an unusually costly month for crypto security. September losses had already been dominated by the roughly $320 million incident involving Liquid Network, where a software vulnerability led to a major Bitcoin drain and network shutdown. Adding Fetch.ai and NuNet pushed reported September exploit losses above $333 million across tracked incidents.
The Most Important Failure Happened Before the Attacker Touched the Contract
The obvious lesson from the Fetch.ai incident is that private keys need to be protected.
That is true, but it misses the more interesting failure.
The real problem is what happened after one key was compromised.
A well-designed security architecture assumes credentials will eventually leak. Employees get phished. Servers get breached. API secrets accidentally reach repositories. Laptops disappear. Malware steals credentials. The question is therefore not simply whether a private key can be protected forever.
It is how much authority one stolen key should have.
In this case, SlowMist’s analysis suggests the answer was essentially enough authority to empty the converter.
That is the structural weakness.
If conversionIn() had independently verified an on-chain burn or lock event, possessing a legitimate signing key alone would not necessarily have been sufficient. If the function had enforced transaction limits comparable to those protecting conversionOut(), the attacker might have faced restrictions on how much could be removed in one transaction.
Instead, several security assumptions appear to have collapsed into the same credential.
This is particularly important because smart-contract audits can create a misleading sense of security when the real trust boundary exists off-chain. A contract can perform exactly as programmed and still produce catastrophic results if its instructions say that a signature from one specific key should be trusted without enough independent verification.
The industry has seen this repeatedly. ApeX’s recent key-compromise incident initially looked like a token-mint exploit before the project said compromised credentials were responsible. Zilliqa had to suspend native transactions after private keys were exposed through a years-old wallet-related vulnerability.
These are different technical failures, but they point toward the same risk: cryptographic systems are only as secure as the infrastructure controlling the credentials that are allowed to operate them.
The NuNet connection makes this incident more interesting still.
Seeing proceeds from two ostensibly separate projects converge on the same attacker wallet raises questions about whether there was a shared operational dependency, common infrastructure, overlapping access, or simply an attacker who found two unrelated weaknesses in quick succession.
That question matters because NuNet was originally incubated inside SingularityNET, while Fetch.ai and SingularityNET now sit within the broader Artificial Superintelligence Alliance ecosystem. That relationship does not prove the compromises had a common technical source, but it makes understanding the complete attack path particularly important.
The safest conclusion for now is narrower: the same attacker is linked on-chain to both incidents, while only the Fetch.ai side has a publicly described root cause involving the leaked authorizer key.
The response will now matter almost as much as the initial exploit.
Exchanges and infrastructure providers have increasingly responded to security uncertainty by restricting affected assets. Crypto.com recently suspended deposits for 22 cryptocurrencies over an unspecified security concern, while INDODAX froze APEX transfers after the compromised-key incident.
For Fetch.ai, the critical questions are whether the compromised authorizer has been fully rotated, whether equivalent single-key dependencies exist elsewhere, and whether future converter designs will require independent on-chain proof rather than trusting one signature.
For NuNet, the unresolved issue is even more basic: investigators still need to establish precisely how an attacker was able to cause or receive an unauthorized mint of more than 408 million NTX.
The $2 million headline is relatively modest compared with some of this year’s largest crypto hacks. The architecture behind it is more consequential.
An attacker did not need to defeat sophisticated cryptography to drain Fetch.ai’s converter. According to SlowMist, they needed one leaked key and a contract willing to trust it.
That is exactly the kind of failure that should worry investors more than the dollar amount alone, because keys can be replaced after an incident. A security model that gives one key too much power has to be redesigned.
Shane Neagle is a financial markets analyst and digital assets journalist specializing in cryptocurrencies, memecoins, prediction markets, and blockchain-based financial systems. His work focuses on market structure, incentive design, liquidity dynamics, and how speculative behavior emerges across decentralized platforms.
He closely covers emerging crypto narratives, including memecoin ecosystems, on-chain activity, and the role of prediction markets in pricing political, economic, and technological outcomes. His analysis examines how capital flows, trader psychology, and platform design interact to create rapid market cycles across Web3 environments.
Alongside digital assets, Shane follows broader fintech and online trading developments, particularly where traditional financial infrastructure intersects with blockchain technology. His research-driven approach emphasizes understanding why markets behave the way they do, rather than short-term price movements, helping readers navigate fast-evolving crypto and speculative markets with clearer context.