Skip to main content
Most wallet security is about one question: who can authorize? Keys are kept offline, split across signers, rotated, and guarded. That work is necessary. It is not sufficient, because the thing that eventually calls the key — a signing service, an operator workstation, an automation host — can be compromised without the key ever leaving its enclosure. A compromised execution path does not need to steal the key. It only needs to ask the key to sign. Policy-gated execution adds a second, independent question that is asked even when the first was answered correctly:
A policy does not make the key safer. It bounds what a valid authorization can achieve: how much, how often, to whom, how fast, and under what delay. That is the research direction behind the WalletWall Vault prototype, and this page explains it before the implementation.
TESTNET · PROTOTYPE · NOT AUDITEDEverything below describes a research prototype in the public Wallet-Wall/walletwall-vault repository: not audited, deployed to testnets only, holding mock assets, and not production custody. WalletWall the application holds no keys and operates no vault. Policy bounds damage; it does not eliminate compromise. See Vault Boundaries & Disclosures and what you can use today.

Case study: unauthorized withdrawals without a proven key theft

On 29 October 2026 Binance reported unauthorized withdrawals from its wallets, which it estimated at about $6.3 billion in assets. Its initial public statements said the incident “may involve a compromised DevOps engineer’s laptop, which allowed an attacker to gain access to a service container and submit unauthorized withdrawal transactions”, and that it had “found no evidence of any wallet private key leak”. A later company statement, reported by The Hacker News, said the investigation had “uncovered additional points of breach”, and the company said it would publish a detailed technical post-mortem once the investigation is complete. Among independent analysts, Elliptic described the attacker as having been able to get the exchange’s own systems to sign transactions rather than stealing its keys, and TRM Labs described a batch of authorizations obtained in advance and executed in one burst.
This investigation is incomplete at the time of writing (1 November 2026). No root cause has been published. Loss figures vary by source. Attribution has been reported by some analysts and agencies and is not asserted here. The statements above are the company’s preliminary statements and contemporaneous independent reporting, cited below; later reporting may change them.
What the incident supports, as a security principle, is narrow and does not depend on the final details:
  • A system can suffer unauthorized transactions without demonstrated private-key theft.
  • Protecting keys and protecting execution authorization are different security boundaries, and an architecture needs both.
What it does not support, and this documentation does not claim:
  • that WalletWall or any policy design would have prevented it, or that WalletWall’s architecture resembles the systems involved;
  • that keys did or did not leak, until the final report establishes it;
  • any root cause beyond what the company itself has stated;
  • any connection to quantum computing.
Sources: Binance, “Security Incident Update” (2026-10-30) and its initial investigation statement (an X post; sign-in may be required); The Hacker News, “Binance Suffers Security Breach Affecting $6.3 Billion in Assets” (2026-10-30); Al Jazeera, “Binance says $6.3bn stolen in biggest crypto heist in history” (2026-10-30).

The second question, in the prototype

The prototype’s vault contracts verify a withdrawal’s signatures first (an EIP-712 typed message signed by the vault owner’s wallet, plus the hybrid post-quantum path), and then ask the policy question before any state changes. Every answer is explicit: a permitted action emits events that record what was allowed, and a refused one reverts with a named error that says why.

Bounded policies

DailySpendLimitPolicy caps how much of one asset one vault owner may withdraw through one vault during any trailing 24-hour window. It is an exact rolling ledger, not a daily reset: allowance returns in the same increments it was consumed, at the instants the individual spends age out. Storage is bounded, so a subject that has filled the ledger is refused rather than approximated. Spend is booked once, at admission, and never re-booked at finalization.
RecipientAllowlistPolicy admits withdrawals only to recipients the owner has listed, unless the owner has deliberately opened the list to any recipient; SanctionsListPolicy refuses recipients on an administrator-managed deny list. Both are stateless predicates over current state, evaluated at admission and again at finalization.
Withdrawals above a configured threshold are authorized and reserved at queue time, then finalized only after a delay, optionally after a quorum of guardians has approved the specific queued operation. The owner can cancel a pending withdrawal during the window. Changes to the verifier, the policy engine and the large-transaction parameters themselves go through a two-day propose-then-apply flow with a bounded grace period, so a pending change cannot be banked and sprung later; credential recovery waits seven days behind a guardian quorum.
CompositePolicyEngine fans one admission check out to several modules and permits a withdrawal only if every active module approves. Composition is deliberately asymmetric: adding a module can only strengthen the effective policy and is immediate; removing one can only weaken it and is delayed, with the module still enforced throughout the pending window.
Limit strength is treated as an order, not a number: arming a limit where none existed or lowering it applies immediately, while raising or removing a limit is delayed. The design rule, from the repository’s policy-control authority design, is that a credential capable of spending must not be able to instantly weaken the restriction limiting that spending, and an emergency control may freeze authority but may never relax it.
Admission happens in check, which may book accounting; finalization uses revalidate, a read-only call that cannot mutate anything, so a misbehaving policy makes finalization fail closed instead of corrupting accounting. Custom errors name the refusing condition; events record queueing, cancellation, approvals, parameter proposals and recoveries, so a reviewer can reconstruct why an action was permitted or refused.

What this does, and does not, change

Status and limits

The policy contracts, composite engine and timelocked governance described here exist in the public repository at version 0.13.31 (22 October 2026) and are exercised by its test suite. They are a research prototype: no audit, no mainnet deployment, no production custody, and no claim that any policy design would have changed the outcome of any real incident. The post-quantum authorization path in the same contracts remains a trusted-attestation and mock-verifier path on Ethereum Sepolia, not on-chain ML-DSA verification; see PQ Evidence, Testnet Rehearsal & ZK/SP1 Status. The WalletWall application reads and explains; it never holds keys, signs on anyone’s behalf or executes a vault action. The MCP tool assess_vault_readiness evaluates whether presented evidence meets the technical readiness criteria; it does not configure, authorize or execute a vault. The six gates that would have to be cleared before any production custody consideration are listed in Vault Boundaries & Disclosures, and all six are not started.

Where to go next

Vault Boundaries & Disclosures

Custody, financial, testnet and quantum-resistance boundaries, and the six production gates.

Key Management & Recovery Model

The non-custodial hard rules and why recovery must be simulated, delayed and cancellable.

PQ Evidence, Rehearsal & ZK/SP1 Status

The separate, read-only gates for post-quantum evidence and testnet rehearsal.

Vault technical readiness in MCP

Evidence-only classification of identity and balance evidence — never vault execution.