DeepSafe

The world's first Cryptographic Random AI Verification Network for trustless verification of any on-chain and off-chain messages.

[DeepSafe @DeepSafe_AI]

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.

[DeepSafe @DeepSafe_AI]

How can AI agents trade and execute safely in financial markets?

Our CEO Raul Heraud explored this question with fellow panelists at @wallet’s Beyond X in Singapore.

Proud to support an evening bringing this conversation to the stage.

[DeepSafe @DeepSafe_AI]

Ring-VRF is the method CRVA uses to select different batches of committee members. The documentation is specific about what its proof reveals and what it does not, and the distinction is worth reading closely.

Ring-VRF separates the identification of a specific signer from the proof that the signer is eligible.

A member proves their public key belongs to a published set without revealing which one. The docs name this directly — "Anonymous Key Ownership Proof: Allows a member to prove their public key belongs to a specified set without revealing which one." The mechanism is a one-out-of-many protocol, whose stated job is to prove that some pkₗ is in {pk₀,...,pkₙ₋₁} without revealing ℓ.

Membership by itself would not be enough. The same step also produces a verifiable random value derived from the member's private key and a random seed. So the proof carries two claims at once: my key is in this set, and this random output came from that key.

What holds those two together is a separate piece. A consistency sub-proof links the Pedersen commitment and the PRF output to the same private key. The documentation is plain about what it is there to stop: "Forgeries using mismatched keys."

Without that link, both halves could hold on their own without establishing that they came from the same key — membership shown with one key, randomness produced from another.

That is the part worth taking from the design. The anonymity is not bought by asking for less. The verifier still checks membership, still checks that the random value derives from the seed, and still checks that both trace back to one private key. What it never learns is which member.

Docs:

https://t.co/nA2gjCgyaE

#DeepSafe #CRVA #Web3Security

[DeepSafe @DeepSafe_AI]

Weekend puzzle.

A contract runs a lottery. To pick the winner, it uses the hash of a block produced after ticket sales close.

Who can influence the result?

A. Nobody. It's a hash.
B. Whoever produces that block.
C. Only the contract's deployer.

[DeepSafe @DeepSafe_AI]

On 1 October, the Ethereum Foundation blog introduced zkAPI, built by the Open Anonymity Project with the EF: a way to pay for a metered API, AI inference first, without the payment being tied to who you are.

You deposit credits into a vault contract on Ethereum once. After that, your device produces a zero-knowledge proof that says, in effect, "a funded note covers this spend and nobody has spent it before." The server checks it, issues a short-lived API key capped in dollars, and never learns which deposit paid.

The design choice worth noticing is where those proofs get checked.

Day to day, spending goes through the server, which verifies spend proofs off-chain. Getting money out is handled differently: "The vault contract verifies the same kind of proof at deposit, close, and escape, so your exit never depends on the server's honesty." A balance can be closed and withdrawn on-chain "even if every zkAPI server disappears."

So the operator is relied on for one thing and not the other. Everyday spending runs through the server. The step that returns your funds is checked by the contract itself.

Not every check in a system has to run on-chain. In this design, the one that guards the exit does.

https://t.co/KPblUUWPJi

#DeepSafe #Web3Security

[DeepSafe @DeepSafe_AI]

Trail of Bits published notes on 18 September on reviewing the Miden zkVM. The part worth reading is what happened before the review started.

Security firms — the same firm included — have published a number of posts describing how they pointed an agent harness at a codebase. This post is about a stage earlier than that: "before code review even starts, agents now allow us to build custom tooling and formal models that improve the quality and depth of our reviews."

Miden has its own assembly language, MASM, and very little tooling around it. The firm had six months of lead time, because the implementation was not yet feature complete. It spent them having its agents build an LSP server, a decompiler, a static analysis engine, and a Lean model of the VM executor. None of that was the review.

Applied during the review that followed, those tools produced concrete results. The static analysis identified over 400 unique locations where type validation could be improved, all of them reachable from the library's public API, as well as one high-severity finding: a remainder supplied by the prover was never validated before being passed to a 32-bit subtraction — "a malicious prover could exploit this to forge Falcon signatures and drain any Miden account controlled by a Falcon key pair." The Lean modeling effort produced 95 machine-checked correctness proofs covering all the binary arithmetic in the core library, and surfaced two more bugs the existing unit tests had not caught.

The detail worth sitting with is smaller than any of those. The decompiler was the single largest piece of the work, over 100 agent-generated commits across months. The firm's own account of where the benefit landed: "The main benefit of this work turned out to be the decompiler's internal analysis frameworks and intermediate representation, which we could reuse for static analysis, rather than the full decompilation pipeline."

The post is direct about why work like this did not happen before. It is "highly exploratory in nature, and the end results and potential payoff may be difficult to predict," which makes it "hard to sell clients on them in advance."

What has changed, on the post's own account, is the cost of a miss: "Today, a failed side project only costs tokens." The payoff is no easier to predict than it was. What a wrong guess costs is smaller.

One thing about this particular case is worth noting on its own. The main benefit ended up somewhere the single largest piece of the work had not been aimed at. That is a payoff shape easier to recognize once the work is finished than to argue for before it starts.

https://t.co/972ijKSY19

#DeepSafe #Web3Security

[DeepSafe @DeepSafe_AI]

🤝 DeepSafe × @DeAgentAI

DeepSafe is partnering with DeAgentAI.

DeepSafe is a verification layer for AI and Web3 — using Ring-VRF, MPC, and TEE to validate AI Agent inputs and outputs, independent of the parties being verified.

DeAgentAI’s AI Token Smart Router is the model gateway. Verification and model access now sit next to each other.

#DeepSafe #DeAgentAI #AIA #VerifiableAI

[DeepSafe @DeepSafe_AI]

Weekend puzzle.

A node operator publishes its source code. The code has been audited, and the audit report is public too.

Does any of that tell you which build is actually running on the node?

A. Yes. The code is public.
B. Yes. The code is audited.
C. No—not on its own.

[DeepSafe @DeepSafe_AI]

On 24 August, a proposal on Neutron titled "TestProp: Preparation for AIATO: AI Agent Takeover" asked governance to make one address the admin of ten contracts, among them six Astroport pools and two Drop contracts. When voting closed on 31 August, it was rejected. Roughly 10.4 million NTRN voted no; about 0.32 million voted yes.

On 19 September, proposal 9, "AIATO: AI Agent Takeover. Phase 1: Agent Admin Registration", asked for the same ten admin changes to the same address, plus an eleventh. It was filed as an expedited proposal and passed when voting closed on 22 September at 02:24 UTC, with about 37.3 million NTRN voting yes.

Cosmos Hub validators halted the Hub to limit losses of ATOM moved there from Neutron, and say the funds secured at restart are held in a community validator multisig.

None of this was hidden. From 24 August, the title, the ten contracts and the address that would become admin were public on-chain. From 31 August, so was the rejection.

The August vote said no to that proposal. It did not stop the same request from being filed again nineteen days later and passing. It ended a vote. It did not end the attempt.

Proposal 5: https://t.co/c1atRWPk16
Proposal 9: https://t.co/7LorAITXVB
Cosmos Hub halt: https://t.co/11iqGhmtsp
Cosmos Hub restart: https://t.co/kNhbpbafrG

#DeepSafe #Web3Security

[Cosmos Hub ⚛️ @cosmoshub]

The Cosmos Hub is stable and running normally.

The funds secured during the restart came from the Neutron governance attack and were bridged to the Hub; there was no vulnerability on the Hub itself. They are now held in a community validator multisig.

Hub validators, the Neutron ecosystem, and affected protocols are coordinating on recovery.

Neutron will share a post-mortem, and a Hub forum update will follow in the coming days.

Thank you to all validators and community members for the swift, coordinated response in support of another network.

[DeepSafe @DeepSafe_AI]

A draft posted to bitcoin-dev this month reworks one small piece of taproot backup. It sits in an individual fork, hasn't been assigned a BIP number, and is still in its earliest form.

The draft addresses backup for unspendable internal keys. One existing approach it cites as motivation is to choose a random r and retain it, so the internal key can be recomputed later.

The draft's mechanism derives a chain code from a tagged hash of a normalized wallet policy. That chain code, the fixed NUMS point H, and a selected derivation path together determine the internal key — in a step the draft describes as being done "without additional secret material."

Its Security considerations section states two things: "The policy and selected derivation are enough to reproduce the internal key," and, in the same section, "Seed backups alone do not reconstruct the policy."

Read narrowly, what the draft changes is which inputs are needed to reconstruct that internal key.

Draft: https://t.co/IiCRQuQPcv

[DeepSafe @DeepSafe_AI]

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?

[DeepSafe @DeepSafe_AI]

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.

[DeepSafe @DeepSafe_AI]

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

[DeepSafe @DeepSafe_AI]

@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.

[DeepSafe @DeepSafe_AI]

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.

[DeepSafe @DeepSafe_AI]

@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.

[DeepSafe @DeepSafe_AI]

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

[DeepSafe @DeepSafe_AI]

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

[DeepSafe @DeepSafe_AI]

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

[DeepSafe @DeepSafe_AI]

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

[DeepSafe @DeepSafe_AI]

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.

[DeepSafe @DeepSafe_AI]

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?