Olivia
Online
DeepSafe
@DeepSafe_AI
The world's first Cryptographic Random AI Verification Network for trustless verification of any on-chain and off-chain messages.
DeepSafe Community
Joined August 2022
154 Following
213.1K Followers
998 Posts
Pinned Tweet
DeepSafe is excited to announce our $3m Seed Round with @AntalphaGlobal @ViabtcCapital @capital_spark @CogitentV @ShardingCapital @Mason_eagle @Gate @SatoshiLab_HK @CKBEcoFund
The core decentralized validation technology of DeepSafe has been accepted by the top international cryptographic academic journal IEEE TIFS, with the document ID being 9903072.
Currently, the DeepSafe network has processed nearly 120 million transaction validations, and the number of active accounts on the network exceeds 2.65 million.
Time to make a better Trust Layer now.
GM.
Two words that get used as if they were one, and shouldn't be.
Ours: encrypted and private. Encrypting something keeps its contents from being read by anyone without the key. Whether anyone can see that it happened at all is a separate question — and "private" gets used for both.
What's your pair?
Weekend puzzle.
A contract checks a condition, then acts on it. Both in the same transaction, atomically.
How old can the thing it checked be?
A. Zero. It's atomic.
B. One block at most.
C. Depends on where the fact came from.
EIP-8365 was added to the Ethereum EIPs repository on 17 September, with status Draft. It proposes retiring 0x00, the original genesis-era withdrawal credential type: exit every active validator that still carries one, and stop processing deposits that would create more.
The proposal reports that the population has fallen from roughly 600,000 to 9,290 since Capella opened one-way conversion, but that the decline has stalled. Of the 9,119 still active, it counts 374 that have not attested for over six months and 253 that have never attested in a 14-month observation window. Its own reading: "These are, with high likelihood, validators whose keys are lost."
High likelihood is as far as it gets, and the proposal has to reason from attestation history precisely because the fact it needs is not in the state. The chain records that a validator is not producing attestations. Whether anyone is still able to act for it is not something the chain records.
What the proposal does supply is a measurement of what that missing fact costs. 4.45% of active 0x00 validators have been offline for 30 days or more, against 0.10% for 0x01 and 0.05% for 0x02. The same observable state, with two different meanings: "Being offline is a transient state for execution-credentialed validators, whose owners can always exit and recover funds, but a terminal state for 0x00 validators with lost keys."
Terminal, when the signing key is the thing that is gone. Voluntary exit needs that key; the execution-layer triggerable exit needs an execution address, which 0x00 credentials do not have. For that subset — and only that subset — both paths are closed, and at the penalty rates cited natural ejection takes roughly 28 years. Other 0x00 holders still have the ordinary exit available; the proposal writes a rule that does not depend on knowing which is which.
No balance is moved by this stage. The unchanged rotation path stays open, and any 0x00 holder who still controls their withdrawal key can use it to recover in full. The lost-key subset — by definition — cannot.
The part worth reading twice is what the proposal declines to do. Rescue proposals for this population have been rejected before on credible-neutrality grounds, because a rescue "adjudicates off-chain ownership claims and selects beneficiaries." So this one does not ask who owns anything. It writes "a uniform rule over a class defined by an objective on-chain property," announced ahead of activation, with the conversion path open to every member throughout.
That is the trade. A protocol that cannot verify a claim can still act on it — by never making the claim the thing it acts on.
https://t.co/UBRFhBDJfc
#DeepSafe #Web3Security
@Eguzo123 You need to restake all your available tDEF. If your current node is active, simply restake to it. If the transaction fails, unstake, wait for the cooldown, then restake to an active node.
To strengthen Sybil resistance and verify genuine active users, DeepSafe is opening a seven-day node verification window.
📅 Verification period: September 17 – 23
🤖 Official Telegram bot: @Deepsafe_official_bot
To activate your eligibility, restake your test tokens to a node you are already staked with.
If the transaction returns an error, your current node is no longer active. Unstake from it, then select a new active node and restake your full available balance in a single transaction.
Please note:
Each node supports up to 4,000 voting participants. Full nodes cannot accept additional votes.
Unstaking requires a one-day on-chain cooldown. If you need to switch nodes, start early and do not wait until the verification window is about to close.
Complete verification before the deadline to remain eligible for this round.
@MustaphaIsaMus1 This is the normal unstaking notice. Unstaking usually takes 24–30 hours and should not exceed 30 hours if the block-producing node stays online.
On 16 September, Lombard deprecated native minting and redemption of LBTC and BTC.b on five chains — TAC, Sonic, Katana, Berachain and Starknet. Holders on the first four are required to bridge balances to Ethereum by December 10. Starknet keeps its bridge, and its balances have no deadline.
Underneath that sits a second change, and it is the more interesting one.
Bridging moves to a hub and spoke model. From the docs: "every supported chain has a bridge lane to and from Ethereum, and a transfer between two other chains routes through Ethereum rather than directly." Minting from native BTC is unaffected. What changed is how already-minted assets move between chains.
The reason is stated plainly: "Fewer bridge contracts and message paths mean a smaller surface to secure and monitor, and security budget and engineering resources concentrate on the lanes that carry the most value."
Worth being precise about what actually shrank. Not the number of chains — every other chain continues, and you can still mint from native BTC on any of them. What shrank is the number of routes between them.
Those are different quantities. In a mesh, routes exist between pairs, so each chain added arrives with a new lane for every chain already there. In a hub and spoke, a chain arrives with one.
The count that goes in the announcement is chains supported. The count that has to be secured and monitored is lanes. A topology decides which of the two grows faster, and that is the decision this update actually makes.
https://t.co/99C3WipeAW
#DeepSafe #Web3Security
Symbiosis has published its post-mortem on the Bitcoin Bridge incident of 11 September. The deposit that set the whole thing off was a real Bitcoin payment worth about 25 cents.
The bridge reads deposit instructions from data attached to Bitcoin transactions, and its decoder "identified the sender using the wrong part of that data: a part the spender controls." That was enough to have the attacker treated as an approved depositor and as the bridge administrator at the same time. With that, they put the minimum fee below zero, and a second bug subtracted the negative fee — which added to the deposit instead of reducing it. Twelve deposits went through across BNB Chain, Ethereum and Rootstock in roughly four minutes.
That first payment did not have to be forged. It was real and it was confirmed on Bitcoin. A check asking whether the deposit had happened would have answered yes, and it would have been right.
The bridge was asking a second question at the same time: who sent it. For that, it read a field — one the sender controlled.
Establishing a sender by signature and establishing one by reading the transaction data end in the same place: a name the system is about to act on. They differ in where the name comes from. A signature asks for something nobody can produce without the key the system already ties to that depositor. Reading it out of the deposit data makes the answer depend on which part gets read, and on that part being beyond the sender's reach.
Symbiosis puts preliminary losses to liquidity providers and affected users at 9.97 BTC. The bridge is offline, and it has commissioned independent audits.
Sources:
https://t.co/YxSokEsot2
#DeepSafe #Web3Security #CrossChain
In March, Google Quantum AI published resource estimates for breaking the elliptic-curve cryptography that Bitcoin and Ethereum rely on. It did not publish the improved circuits those estimates came from. The abstract explains the choice in a sentence — "In the interest of responsible disclosure, we use a zero-knowledge proof to validate these results without disclosing attack vectors."
What it did release was the paper, the zero-knowledge proof, prover and verifier code, and the accompanying artefacts.
A paper posted to arXiv on September 9 shows what happened next. Over roughly eight weeks, participants working alongside AI agents optimised one step of the attack — reversible point addition on secp256k1 — against a public leaderboard. The score being minimised was Q×T: peak logical qubit width times average executed Toffoli count. It went from 10.75 billion at the challenge's starting baseline to 1.496 billion, a reduction of 86.1%. The best circuit at the data cutoff uses 1,151 qubits and 1,299,453 average executed Toffoli gates.
Worth stating plainly what that is and is not.
It is a point-addition benchmark, measured against the challenge's own baseline, under accounting conventions the paper itself flags as different from Google's. It is not a halving of the cost of running Shor's algorithm against secp256k1, and the paper does not claim to have measured that.
What it does show is the part we find interesting, and it took two separate pieces of work rather than one. Google's improved circuits stayed unpublished throughout; what it put out was enough to let others verify the resource bounds it claimed for those circuits, and to reuse its code. The challenge organisers then built the things a competition needs and Google had not provided — a target, a locked evaluator that settles whether a candidate qualifies, a leaderboard — with their benchmark harness adapted from that released code. Together they were enough for the work to accumulate without the circuits.
That is one case, not a rule. But it is a case where withholding a specific attack and letting other people work on the same problem turned out not to be in conflict.
Proof, not promises. In this case the proof is someone else's.
Sources:
https://t.co/tfvhvNhyEY · https://t.co/mDgtwlI59v ·https://t.co/ObnYCvZwEF
#DeepSafe #ZeroKnowledge #Web3Security
EIP-8025 is a draft that would let Ethereum consensus nodes check a cryptographic proof that a block's transactions were executed correctly, in time that stays flat no matter how much gas the block used. Today a node establishes that by running the transactions itself.
The interesting part is not the proof. It is where the draft declines to put it.
A verified proof does not replace re-execution — the spec calls it "an additional signal, not a replacement." It is not wired into fork choice or attestation, the two things that decide which block a node follows and what it votes for. A node that has not received a proof does not wait for one. And a forged proof cannot fork the chain or get anyone slashed; its effect stops at the local view of the node that accepted it.
The proof is real, and it does something. It is just not load-bearing.
The draft is explicit about why, and about what comes after: treating proofs as a non-critical artefact "lets the stack mature on a live network," and "a separate, future EIP could subsequently propose making execution proofs mandatory once they have matured."
That is a deployment order, written down. Ship the mechanism somewhere its failures are survivable. Gather proof sizes, generation latency and client behaviour from a real network. Then argue, in a separate document, for giving it a job the chain depends on.
What that sequence separates is worth naming. Whether a verification method works is one question, and cryptography answers part of it — the rest comes from the implementation, the inputs it is handed, and how it holds up in production. What that method is permitted to decide is a different question, and it is settled by design rather than by strength. Operational history is not the source of that authority. It is the evidence you want before granting it.
The two questions are easy to merge, because a check usually arrives already attached to whatever the surrounding code does with its output. Pulling them apart takes deliberate work, and this draft does it on the page.
The same two questions apply to what we build. CRVA verifies on-chain and off-chain data using nodes selected at random. What a result is permitted to decide is not a property of the verification itself. It is a choice made by the system integrating it — one worth stating explicitly rather than inheriting from whatever the surrounding code happens to do.
A check can be sound long before it is ready to be depended on. The draft's contribution is making that boundary explicit.
Sources:
https://t.co/tT8jvwr8jj
#DeepSafe #CRVA #Web3Security
Answer: none of them.
Green only means no failure was reported. It doesn’t prove that checks ran—or that there was anything to catch.
Weekend puzzle.
Every dashboard is green. No alerts. No incidents all week.
That could mean:
Everything passed.
Nothing was checked.
Nothing worth checking happened.
Which one does a green dashboard rule out?
GM.
Every security claim should come with its boundary:
"This does not protect you from ______."
What would you put in the blank?
New custody schemes are often demonstrated the same way. A key is generated, a transfer is signed, the properties hold. The demonstration is real. It is also evidence about a system that started empty.
The harder case is a live system that did not. It is already holding funds under signatures produced by the scheme being replaced.
Migrating one can take time. In a staged migration, some balances may already sit under the new arrangement while others remain under the old one. Both control paths may be live.
Neither scheme's analysis necessarily covers that state.
The old scheme's security argument covers the configuration being taken apart. The new one's covers a configuration that is not yet complete. Unless the transition is specified as a procedure in its own right, it can fall outside both arguments — and what stands between an attacker and the funds still under migration is that procedure: the order of operations, the access controls wrapped around it, and how much of it was rehearsed under production-like conditions.
That procedure can be given cryptographic structure — key handover can be defined and verified as a protocol step. Where it is not, it falls to operational work, performed under schedule pressure, on a live system where pausing carries consequences for other people's money.
This is not an argument against migrating. Custody schemes have to be replaced, and the reasons are usually good ones. It is an argument about which part of the plan gets the scrutiny. The new scheme may receive pages of analysis. The transition may receive a schedule.
CRVA does not remove this problem and we are not going to claim it does. Where authority rests on a standing set — of keys, of signers, of machines — any change to that set has to be carried out somehow, and the question is whether that interval is specified and verified or simply scheduled. CRVA's answer is not to avoid that interval. The Agents holding key shares are reselected at random on a fixed cycle, and passing the shares from the outgoing set to the incoming one is a defined step in the protocol rather than a one-off project. Under threshold MPC a valid signature requires enough participants to contribute, so no single participant can produce one alone. What that buys is a transition exercised constantly instead of rarely. What it costs is that the interval is never far away — which is a reason to scrutinise the procedure, not to assume it away.
Each scheme was analysed as a destination. The migration is the part that is neither.
#DeepSafe #CRVA #Web3Security
In a bull market, every project has a story.
But when the narrative, the numbers, and the team point in different directions—which one do you trust?
Join DeepSafe for an open conversation on how we evaluate projects, separate real signals from market noise, and avoid the traps behind convincing stories and polished data.
🎙 Host: Kolverses🪽 @kolverses
🎤 Guest Speaker：
Cindy胖迪🥰 @CindyCreation
GiGi 發財豬 @gigiz_eth
Mr.Bai 白先生 @Baisircrypto
🗓 Sep 12 · Sat 21:00 UTC+8
🎙 X Space
🔔 Set a reminder: https://t.co/RYxfIvW8iv
A system that checks something ends up with an answer to what happens when the check cannot run.
Not when the check fails — when it is unavailable. The service is down, the endpoint times out, the attestation cannot be retrieved, the quorum cannot be assembled. The request is still there, and the system still has to decide what happens to it.
The two simplest answers are to let it through or to hold it. Real systems have more room than that — retry, queue, fall back to a weaker check, cap the amount, route it to a person — but each of those still resolves into proceeding or not, and each has its own behaviour when the fallback is unavailable too.
Both directions are defensible. A payments system that holds every transaction whenever a fraud check is unreachable has converted an availability problem into an outage. A vault that releases funds whenever its verifier is unreachable risks turning an availability problem into a withdrawal. Which cost is worse depends on what is being protected, and reasonable teams land in different places.
What is worth noticing is that the answer can exist without ever having been an explicit design decision.
The behaviour ends up wherever the error path happens to go. A timeout can return a permissive default. A general exception handler can let execution continue. A check added late can be wrapped in a conditional that skips it when a dependency is missing. The code may never contain a line reading "if verification is unavailable, proceed" — but that can still be exactly what it does, and it will do it just as readily when someone is making the checker unavailable on purpose.
This is why the choice is worth writing down before it is discovered. A system that fails open by decision has weighed the trade. A system that fails open by accident has the same behaviour and none of the reasoning, and it learns which one it is from an incident rather than from a design review.
For a verification layer the question is sharper, because an attacker may target its availability rather than defeat the check itself. If no result means no check, then the verifier does not have to be broken. It only has to be kept from answering.
CRVA changes the dependency rather than removing the question. The Agents that sign are selected at random from a larger population and rotate on a fixed cycle, and under threshold MPC a valid signature requires enough participants to contribute, so no single participant can produce one alone. That reduces reliance on any one verifier. It does not guarantee that a result always arrives, and it does not settle what the surrounding system does when one does not. That stays with whoever integrates the check — which is the same decision this whole piece is about.
Every system has an answer to this. The question is whether anyone chose it.
#DeepSafe #CRVA #Web3Security
On September 2, TAC published its post-mortem on the August 22 incident that drained its staking pool. The section worth reading twice is not the one about the vulnerability. It is the one about what was watching.
Two controls were running: an automated check comparing TAC's custody against the mirrored supply on BNB Chain and Ethereum, and alerting on large bridge transfers. Both were doing the jobs they were designed to do.
The first had nothing to flag: the attacker locked genuine TAC and issued a correctly backed mirror token, so the conservation property it monitored was never broken. The books stayed balanced.
The second monitored large bridge transfers. Only 32 seconds separated the drain from the first bridge transfer. In TAC's own words: "No control that ends in a human decision closes an interval of that length." That is not a point about how fast anyone noticed. It is about everything that would still have to happen after detection.
This was a drain, not a mint — no new tokens were created. Mainnet resumed on September 2, and the staking pool has since been restored in full.
So the usefulness of a control turns on two properties. Which invariant it watches — because an attack that preserves that invariant stays invisible to it, however correctly the check itself runs. And whether it can act without waiting for someone — because a control that ends in a person inherits that person's response time.
CRVA is designed for a different control position. Where an applicable check is already integrated into a request's execution path and its result is enforced, Agents drawn for that request can return a verdict before the request proceeds. That is not a claim that CRVA would have prevented TAC's internal state-transition flaw. The published record does not establish that an applicable CRVA check was integrated into this execution path. The distinction here is about where a control can act, not about which controls are better.
Both of TAC's controls worked as designed. Neither was an enforcement gate on the transaction that drained the pool.
Sources:
https://t.co/CpY2b8HGZd
#DeepSafe #CRVA #Web3Security
🎉The DeepSafe Community Quest starts today — a month to explore, create and contribute alongside the community, with 2,000 USDC in rewards.
Whether you have been following DeepSafe for a while or are just joining us, there are plenty of ways to take part.
Complete the mandatory checklist to unlock eligibility, then earn more points by engaging with official posts, sharing your own perspective, creating original content, joining the conversation in Discord and inviting friends.
🏆 2,000 USDC reward pool
📅 September 9 — October 9
📈 More points, a larger share of the pool
Bring your ideas. Make something original.
Start the Quest: https://t.co/7uVaopAafP
#DeepSafe #CRVA
On September 5, Core DAO published its post-mortem on the reward-accounting exploit that ran from August 28 to 31. Roughly 255M CORE of rewards were issued ahead of schedule.
The cap held. In Core's words, the exploit "did not create any CORE beyond the protocol's limits; the 2.1B maximum supply was never violated." What it did was accelerate rewards the emission schedule would otherwise have released later. What broke was when.
That makes the damage an unusual shape. No user or staking account was drained — Core states that no user or staker funds were lost and that delegated stake was never at risk. What existed instead was surplus, sitting in balances, and it arrived through the ordinary path: the extra rewards "appeared both in attacker-controlled addresses and, unintentionally, in the reward addresses of honest validators who simply received an inflated payout they did not cause."
That made the on-chain reconciliation an arithmetic problem before it was a balance-editing problem. Before any affected balance could be corrected, Core needed a rule for what that balance should have been at the upgrade block.
It used two. Attacker-controlled reward pools were set to zero. For affected honest validators, it defined a fair-earnings floor — the pre-incident balance plus three rounds of that validator's own normal reward — left balances at or below it untouched, and removed only the excess above. Together the reconciliation took 186,153,491 CORE out of supply by direct state reduction. A further ~69M had been moved before the upgrade and sits outside what an on-chain reconciliation can reach; Core says it is pursuing that with law enforcement.
Core says the reconciliation can be checked independently against chain state at the upgrade block, and that the reward paths were subsequently reviewed by Halborn. That part matters as much as the fix. A correction that affected users and independent observers cannot verify is only a second assertion about the balances.
A supply cap is a promise about how much will ever exist. It says nothing about how much should exist yet. Restoring the second one requires knowing a number the cap never had to track.
Sources:
https://t.co/TMhZdwRHaQ
#DeepSafe #CRVA #Web3Security
A draft Ethereum standard for AI agents keeps reputation and validation in two separate registries. Both are records. Neither is a guarantee, and the proposal is candid about that.
"Trustless Agents" was created in August 2025 and is still a Draft. It defines three registries: identity, reputation, validation.
The Reputation Registry takes feedback from client addresses — a score, optional tags, pointers to supporting data. It supports on-chain filtering by reviewer and by tag; the proposal expects more complex aggregation to happen off-chain. Its own Security Considerations say the rest plainly: Sybil attacks are possible, inflating the reputation of fake agents. The registry's contribution is to make signals public and put them in one schema.
The Validation Registry records a request for a named validator contract to check a piece of work, followed by that validator's response. The response ranges from 0 to 100 and can represent binary pass/fail or an intermediate outcome. The validator may respond more than once to the same request, enabling updates such as soft and hard finality. It may use stake-secured re-execution, a zkML verifier, a TEE oracle or a trusted judge. The registry is agnostic about which.
Both registries standardise the shape of a trust signal and leave its reliability to the party and procedure behind it. For a registry, that is a reasonable boundary. It also means neither record becomes reliable by being on-chain.
One line sets up the question the proposal leaves open. A validation request must be submitted by the owner or operator of the agent, and the request names the validator address — but the ERC does not say how that validator should be chosen. Incentives and slashing are likewise left to the surrounding validation protocol. CRVA works on that layer: Ring-VRF draws the verifier set for each request, so the set is not fixed in advance. That reduces one selection risk: a set that persists across requests gives an attacker time to prepare. It does not make the check itself correct.
A registry can record who said what. Whether they were right is a different question. Who gets asked is a third one.
Source:
https://t.co/rpBV5ERoya
#DeepSafe #CRVA #Web3Security
Last Seen Users on Sotwe
Trends for you
Most Popular Users
Elon Musk
@elonmusk
241.7M followers
Barack Obama
@barackobama
119M followers
Cristiano Ronaldo
@cristiano
114.3M followers
Donald J. Trump
@realdonaldtrump
111.8M followers
Narendra Modi
@narendramodi
107.2M followers
Rihanna
@rihanna
98.7M followers
NASA
@nasa
92.4M followers
Justin Bieber
@justinbieber
91.8M followers
KATY PERRY
@katyperry
89.9M followers
Taylor Swift
@taylorswift13
83.9M followers
Lady Gaga
@ladygaga
75.4M followers
Virat Kohli
@imvkohli
73.3M followers
Kim Kardashian
@kimkardashian
70.9M followers
YouTube
@youtube
68.8M followers
Neymar Jr
@neymarjr
66.3M followers
Bill Gates
@billgates
65.1M followers
Selena Gomez
@selenagomez
63M followers
The Ellen Show
@theellenshow
62.3M followers
CNN
@cnn
61.8M followers
X
@x
60.7M followers