Internet-Draft Crypto Execution Finality November 2026
Das Expires 22 May 2027 [Page]
Workgroup:
Independent Submission
Internet-Draft:
draft-das-crypto-execution-finality-00
Published:
Intended Status:
Informational
Expires:
Author:
S. Das
Independent

AI Safety and Custody Security: Execution Finality at the Signing, Delegation and Withdrawal Boundaries of Cryptocurrency Systems

Abstract

A cryptographically valid signature can authorize a transaction that the organization never intended. The hard problem in digital-asset custody is therefore not only protecting keys. It is stopping compromised workflows, delegated code, misleading transaction displays, stolen credentials, and legitimate automation (including AI agents) from turning broad technical capability into unrestricted transfers.

This document proposes defender-controlled, consequence-specific authorization at three boundaries: signing, wallet execution, and withdrawal release. The defender reconstructs the operation that would actually take effect from the transaction bytes and account state, holds it in a non-effective state, evaluates it against independent policy and a protected exposure ledger, and releases only a bounded, act-bound, single-use authority at a mandatory enforcement point. The document specifies placement by chain type, requirements, a state machine with crash and reorganization handling, EIP-7702 delegation controls, a catalogue of edge cases and twenty-four threat scenarios, and an acceptance-test method with a reference simulator. It states the limits plainly: an off-chain gate cannot stop a leaked key that submits directly to a permissionless network, and it fails if the enforcement layer is bypassed or compromised. No deployment, measured latency, or real-world prevention is claimed.

Status of This Document

This note is to be removed before publishing as an RFC.

This is an individual, independent-submission Internet-Draft. It is a technical proposal and has not been adopted by any IETF working group.

Basis of disclosure: this document is based on the Mothership application PCT/IB2026/055615, filed 4 June 2026 and publicly disclosed (published as WO 2026/150382 A2) on 16 July 2026. The full filing can be read by searching "Sangam Das" on WIPO PATENTSCOPE, by searching PCT/IB2026/055615 (pctib202655615), or at https://www.tdcommons.org/dpubs_series/12542/ . The filing text, not this draft, is authoritative for the patent disclosure.

Incident descriptions are drawn from public third-party reports and are treated as reported accounts, not as independently reconstructed chain forensics. Any mention of products, standards, or organizations is for technical context only. It is not an endorsement, validation, or statement of infringement, and no third-party adoption is implied.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 22 May 2027.

▲

Table of Contents

1. Introduction

Digital-asset custody has strong cryptographic building blocks: hardware security modules, multi-party computation, multisignature wallets, smart-contract wallets, transaction simulation, allowlists, rate limits, and chain monitoring. Large losses still occur when a signature that verifies correctly authorizes a consequence nobody approved. A multisignature threshold can be met while signers read an altered display. An HSM can correctly sign a request produced by compromised middleware. A delegated account can run code whose powers are far broader than its owner understood. A hot wallet can be emptied within minutes, faster than any human response.

Two public incidents motivate the problem, and this document keeps them separate (Section 3). The February 2025 theft from a major exchange involved tampering with a multisignature signing interface. The October 2026 reported theft from a major exchange's hot wallets involved leaked signing capability and, on at least one chain, an EIP-7702 delegation [EIP-7702]. Neither incident is reconstructed here, and this document does not claim the proposed architecture would have prevented either.

The architecture here asks one additional question at the last enforceable boundary: given the exact bytes, account state, destination, value, code, and remaining exposure budget, may this specific operation take effect now? It complements multisig, MPC, HSMs, contract audits, risk engines, and monitoring. It replaces none of them.

1.1. Scope

The document covers: signing services and HSM or MPC policy layers; programmable wallets and smart accounts on EVM-compatible chains; centralized-exchange withdrawal release; bridge and treasury-upgrade paths; and AI agents or automation that prepare or request such operations. It addresses non-programmable chains only at the signing and release boundary, where on-chain policy is unavailable.

1.2. Non-Goals

  • Preventing phishing, key theft, or malware infection on user or staff devices.
  • Overruling a public blockchain: a validly signed transaction submitted directly to the network executes according to the chain's rules.
  • Replacing smart-contract auditing, formal verification, or consensus security.
  • Attributing any incident to any actor.

1.3. How to Read This Document

Sections 3 to 5 give the evidence, the problem, and the threat model. Sections 6 to 11 give the architecture, requirements, data objects, state machine, and exposure accounting. Sections 12 to 18 cover EIP-7702, signing hazards, custody models, independence, agents, bridges, and edge cases. Section 19 is the threat-scenario catalogue. Section 20 and Appendix A give the evaluation method and the reference simulator results. Appendix B collects objections.

2. Terminology

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

The names below describe architectural roles in this proposal. They are not established protocol or standard terms.

Protected Consequence
An effect whose unauthorized occurrence is unacceptable: a transfer, an allowance or permit, a code-delegation change, a withdrawal, a contract upgrade, a bridge release, a key or credential issuance, or a signature that releases any of these.
Candidate Act
The defender-side representation of the operation that would actually take effect, reconstructed from transaction bytes, calldata, account state, code hashes, delegate paths, and asset semantics, not from a request's description or a user-interface rendering.
Non-Effective State
A staging state in which the Candidate Act has produced no protected effect.
Protected Validator
A defender-controlled component, isolated from the transaction builder, that evaluates policy for a Candidate Act.
Finality Sink
The enforcement point that refuses to sign, execute, or release a Protected Consequence unless valid, current, act-bound authority is verified. It can be a protected signer, a wallet or contract rule, or an exchange withdrawal-release service.
Bounded Authority
Authorization limited to one Candidate Act or one narrow capability, by asset, amount, beneficiary, chain, target, code hash, time, and security epoch, consumable a bounded number of times.
Exposure Ledger
A protected shared record of committed and reserved value, supporting atomic reserve, commit, and release across parallel signers, agents, and chains.
Receipt
Authenticated evidence that binds a phase and its observed result to a Candidate Act, used for reconciliation and for deciding later authority.
Mandatory
A control is Mandatory for an effect if no route reaches that effect without passing it. Everything in this document depends on this property.

3. Incident Evidence and Factual Separation

3.1. Reported Exchange Theft, October 2026

Public reports describe a large theft from a major exchange's hot wallets on 29 October 2026, on the order of USD 6.3 billion across several chains, including an Ethereum address labelled "Binance 14" on a block explorer. Reports describe an EIP-7702 delegation installing attacker-chosen code on that address, with the transfers submitted by a different address. Reports also say the delegation explains only part of the total: withdrawals on chains without account delegation, and ordinary signed transfers from another Ethereum wallet, were also reported, and several analyses point to how signing capability was obtained as the root cause rather than to the delegation feature [INCIDENT-REPORTS]. Some analyses describe about fifty delegation authorizations of which one matched the live account nonce. At least one source labels its nonce-range explanation as its own inference, so this document treats it as a test case, not as established fact.

All figures and mechanisms in this section are third-party accounts requiring independent on-chain and primary-source confirmation.

3.2. Reported Exchange Theft, February 2025

The February 2025 loss, reported at about USD 1.5 billion, is a separate case. A Japanese Financial Services Agency research paper discusses tampering with a multisignature wallet's web interface and misleading signer presentation [FSA-BYBIT]. EIP-7702 is not established as the mechanism of that theft, and the two incidents MUST NOT be conflated.

3.3. Reported Outage-Themed Phishing, November 2026

Following a Microsoft 365 service disruption on 12 November 2026, Microsoft Threat Intelligence reported a campaign on 13 November 2026 impersonating service-health notices, claiming held mail would be deleted within 24 hours unless a link was followed, and assessed it as consistent with credential phishing [MSFT-PHISH]. Public evidence does not establish credential capture, account takeover, or any downstream cryptocurrency loss. This document uses the campaign only as a plausible entry-stage pattern (Section 19.15).

3.4. What the Evidence Supports

Table 1: Evidence, supported reading, and caution
Evidence Supported reading Caution
Exchange theft, Oct 2026 Valid signing capability plus delegation to attacker code on at least one chain Third-party reports; delegation does not explain all losses; root cause of key or signature compromise not established here
Exchange theft, Feb 2025 Compromised signing presentation in a multisig workflow Separate event; not an EIP-7702 case
Outage-themed phishing, Nov 2026 High-volume credential-phishing lure No established account compromise or custody impact
This proposal Candidate Act plus independent consequence gate Proposed; not shown to prevent any incident

These events support a defensible question: how can a custody system tell technically valid signing or execution apart from authorization of the actual destination, value, code path, and effect? They do not prove the proposal was present, absent, novel, effective, or sufficient.

4. Problem Statement: A Signature Is Not Consequence Authority

A signature proves that a signing capability was used under specified rules. It does not prove the organization intended the real downstream effect. Define the invariant:

No Protected Consequence occurs unless the reconstructed effective operation satisfies a fresh, independently evaluated policy and the final effectuation boundary enforces that decision.

The invariant is conditional on complete mediation. If a private key or an existing on-chain allowance permits a direct, unmediated transfer, an external validator cannot stop it afterwards.

4.1. Why Conventional Controls Can Leave a Gap

Modern custody already uses transaction policy engines, MPC approvals, allowlists, rate limits, time delays, code simulation, and monitoring, and these block many attacks. The claim here is narrower than "conventional controls fail". It is that three structural gaps can remain even when each control is correctly implemented.

Semantic gap
Controls verify who or what is signing, not necessarily what the final operation does. Multisig counts signatures over bytes signers may have seen misrepresented. An HSM signs a digest it is given. Simulation predicts behavior, but hidden state changes, upgradeable proxies, time-dependent logic, and multi-step composition can defeat it. Allowances and delegations grant future power without moving funds at signing time.
Irreversibility gap
Settlement on public chains is final within minutes. Monitoring and alerting detect, but a loss that completes in about twenty minutes is faster than most response processes. Detection is necessary and is not prevention. Evidence after the effect cannot undo it.
Mediation gap
A control protects only the routes that pass through it. A leaked raw key, an alternate signer, an emergency credential, a batch job, a direct RPC submission, a second chain, or a previously issued permit can reach the effect without passing the gate. Per-chain controls miss global intent. Per-transaction caps miss aggregation.

The table below states, for common controls, what each establishes and what can remain open.

Table 2: Conventional controls and residual gaps
Control What it establishes Residual gap
MFA, IAM, conditional access Identity or permitted service access Not exact asset, destination, or code intent
Multisig Threshold of signatures Signers can approve misrepresented bytes
HSM / MPC Key protection, distributed signing Compromised request construction; policy often limited to simple fields
Allowlists, per-transaction caps Known destination, bounded single transfer Approvals, delegations, and aggregation can bypass
Transaction simulation Predicted call behavior Hidden state, mutable code, ordering, and composition
Monitoring, alerts Detection and investigation Late relative to irreversible settlement
Smart-contract audit Review of code at a point in time Upgrades, delegation to other code, deployment-time substitution
Finality gate (proposed) Exact protected effect authorized Fails if bypassed, corrupted, or the key submits directly to the chain

AI agents enlarge the surface by composing tools, iterating after failure, and operating at volume. The same finality problem exists without AI.

5. Threat Model

5.1. Protected Assets

Funds and tokens under custody; allowances and permits that confer future spending; delegations and account code; signing keys and key shares; policy and governance state; upgrade authority; bridge release authority; withdrawal queues; and the evidence and ledgers that record exposure.

5.2. Attacker Capabilities

The attacker MAY:

  • compromise the transaction builder, dashboard, signer front end, or an AI agent, and control what operators and signers see;
  • hold stolen service credentials, staff credentials, or one of several approver credentials;
  • request many signatures, including speculative ones over nonce or parameter ranges;
  • send requests in parallel across workers, agents, and chains;
  • exploit retries, timeouts, reorganizations, and replacement transactions;
  • replay old approvals, old policy bundles, or old receipts;
  • induce a signer to authorize delegation to attacker-chosen or mutable code;
  • attempt denial of service against the validator to create pressure to fail open;
  • claim in natural language, or through a compromised agent, that an operation is approved.

5.3. Trust Assumptions

The protection in this document holds only if all of the following hold for the covered effects: the Finality Sink is Mandatory; the Protected Validator and policy authority are not controlled by the attacker; signing keys are non-exportable or the on-chain rule is itself mandatory; and the attacker does not simultaneously control the validator, the sink, the policy authority, and the audit and reconciliation channels. Section 25 lists what happens when these fail.

5.4. Out of Scope

Consensus attacks; compromise of a chain's client software; legal seizure; and attacks that need no signature (for example, direct exploitation of a vulnerable contract that holds funds) are out of scope except where they bear on the sink's placement.

6. Architecture

The attacker never has to take part. The defender builds the Candidate Act from what actually arrives at a defender-controlled boundary.

 Request / workflow / AI tool / operator command
        |
        v
 Reconstruct actual operation: target, value, chain, calldata,
 code hash, beneficiary, allowance and delegation effects
        |
        v
 Hold as Candidate Act (NON-EFFECTIVE)
        |
        v
 Protected Validator: independent policy, fresh state,
 epoch, revocation, exposure ledger reservation
        |
   +----+--------------------+
   |                         |
 deny / hold /          issue Bounded Authority
 reconcile              (act-bound, single use)
   |                         |
   v                         v
 NO EFFECT            Finality Sink verifies authority + exact bytes
 (fail closed)        at signer / wallet rule / withdrawal release
                              |
                              v
                     Bounded effect + Receipt
Figure 1: Defender-side control sequence (schematic, not an observed incident trace)

6.1. Three Control Planes

A. Pre-signing control
The gate sits inside the protected signing service, MPC policy quorum, or an HSM-adjacent authorization service, not in a web dashboard. It inspects the exact bytes or canonical semantics being signed, never an untrusted UI rendering, and the signer MUST be unable to sign protected effects through another path. Signing is itself a consequential release of authority, because a signed transaction can be broadcast later or through another relay.
B. On-chain smart-wallet control
Where assets sit in a programmable account, the rule is enforced in the actual contract execution path: destination allowlists, asset and value limits, session constraints, delegate-code allowlists, timelocks or vetoes. An off-chain decision alone is not enough if a valid key can invoke an unrestricted transfer directly.
C. Exchange-controlled release control
For centralized withdrawals, enforcement sits at the last internal release boundary: the custody transaction builder, signing authority, and broadcast control bind the approved withdrawal request to the exact destination, asset, chain, and amount. Post-broadcast reconciliation is required, but post-event monitoring is not preventive authorization.

No single location fits every chain or wallet design. Several gates may be needed. The decisive property is that every protected effect path is mediated.

6.2. The Attacker Does Not Implement Candidate Acts

A hostile builder, agent, or stolen credential simply sends ordinary requests. The defender reconstructs the Candidate Act. The attacker cannot avoid the gate by refusing to use it, provided the effect cannot be reached through an unmediated path.

7. Requirements

R1. Bytes-derived reconstruction.
The gate MUST derive the Candidate Act from the transaction bytes, calldata, account state, code hashes, delegate paths, and asset semantics. It MUST NOT rely on a memo, API endpoint name, or user-interface text. It MUST account for indirect effects: approvals, permits, delegatecall, multicall, hooks, and downstream recipients.
R2. Complete mediation.
Deployments MUST enumerate every route to each Protected Consequence (raw key, alternate signer, emergency signer, direct RPC, private relay, batch job, upgrade admin, bridge executor, previously issued allowance, second chain) and MUST either gate each route or record it as residual risk. A claim of non-bypassability MUST NOT be made without that inventory.
R3. Independent policy authority.
Policy MUST be held by an authority the transaction builder cannot modify. Policy updates MUST be authenticated, quorum-approved where feasible, versioned with a monotonic epoch, and protected against rollback (Section 19.22).
R4. Bounded authority.
Authority MUST specify asset, maximum value, cumulative exposure, beneficiary set, chain identifier, target contract, calldata constraints, delegate-code hash, source wallet, expiry, nonce, security epoch, and execution environment. Unspecified fields MUST NOT become wildcards.
R5. Act binding and single use.
Authority MUST be bound to one Candidate Act or one narrow capability and MUST be consumed at most the permitted number of times, by the intended sink only. It MUST NOT behave as a transferable bearer token.
R6. Atomic exposure accounting.
The Exposure Ledger MUST reserve value atomically before signing, across all parallel signers, agents, and chains, and MUST hold the reservation through uncertain outcomes (Section 11).
R7. Delegation and approval are consequences.
Granting a delegation, an allowance, a permit, a session key, or an upgrade right MUST be gated as its own Candidate Act, because it confers future power without moving funds at signing time.
R8. Refuse unapproved authorizations.
A protected signer MUST NOT produce delegation authorizations, typed-data permits, or similar future-power signatures except for an approved Candidate Act. It MUST NOT sign speculative batches over nonce or parameter ranges.
R9. Anti-replay.
Authorizations, receipts, and policy bundles MUST carry freshness (nonce, counter, or epoch) and sink-local consumption state. Old approvals and older policy epochs MUST be rejected.
R10. TOCTOU closure.
The decision MUST be bound to an integrity-protected digest of the final operation, the target state version, and the policy epoch, and MUST be rechecked at the sink immediately before or atomically with the effect.
R11. Reconciliation, not blind retry.
After a timeout, crash, replacement, drop, or reorganization, the system MUST enter HOLD and RECONCILE against authoritative chain state. It MUST NOT sign again with fresh authority until the original outcome is established or explicitly compensated.
R12. Fail closed, tiered.
If required authority is absent, stale, or unverifiable, the gate MUST prevent high-risk effects. Routine low-risk transfers MAY proceed on a local fast path using signed policy and protected local counters, so that an outage does not itself create pressure to disable the control.
R13. Independence.
The Protected Validator, policy authority, and signer MUST NOT share an administrator, credential store, or deploy pipeline whose compromise defeats all three. Shared-failure analysis is REQUIRED (Section 15).
R14. Governed emergency paths.
Break-glass and emergency-signer paths MUST require dual control, carry a small bounded budget and timelock, and be logged to an independent record.
R15. Evidence before effect.
For consequential acts, authorization evidence SHOULD exist before or atomically with the effect. Receipts MUST be authenticated and bound to the act.
R16. Honest limits.
Implementations MUST state which effects are covered, which routes are not mediated, and what happens if the sink, validator, or key custody is compromised.

8. Finality Sink Placement

8.1. Placement Rule

Place the sink in the lowest practical trusted component that exclusively controls the effect, and make every equivalent path converge on it. A check higher in the stack is supplementary if an alternate API, batch job, privileged account, or direct signer can reach the same effect.

8.2. Placement by Consequence

Table 3: Effective gate and critical bypass to close
Consequence Effective gate Critical bypass to close
Hot-wallet transfer Protected signer plus wallet contract rule Raw key or unrestricted RPC signer
EIP-7702 delegation Protected signer refusing unapproved authorizations; delegated-code policy Direct signature offline; malicious or mutable delegate code
Token approval or permit Allowance cap and spender review at signer or wallet Previously issued permit; setApprovalForAll
Exchange withdrawal Custody release, sign, and broadcast control Privileged batch job or emergency key
Bridge mint or release Bridge verifier or release contract; dual-side proof Alternative bridge executor
Treasury or contract upgrade Governance timelock and upgrade executor with independent veto Unmediated admin upgrade
Key or share release HSM or MPC policy before share release Alternate signer; exportable key
Policy update Quorum-signed policy with anti-rollback epoch Builder-side policy edit; replay of old bundle

8.3. Placement by Chain Capability

On-chain policy exists only where the chain's account model supports it. Elsewhere the gate must be at the signer or withdrawal-release layer, and the protection ends at that boundary.

Table 4: Where enforcement can live, by account model
Account model On-chain rule possible? Where the gate must sit Main limit
EVM externally owned account (EOA) Not by default; possible after delegation to a policy module Protected signer; delegation approval A leaked key can sign and submit directly
EVM smart account or ERC-4337 wallet Yes (modules, session keys, validators) Contract rule plus signer Upgrade authority and module bugs
EOA delegated under EIP-7702 Yes, inside the delegated code Signer approving delegate hash; delegate policy Delegate code quality; re-delegation by key holder
UTXO chains (for example Bitcoin) Limited by script HSM or MPC policy and release layer Script-level covenants limited
Other account-based non-EVM chains Chain-specific Signer and release layer Varies by chain features
Centralized exchange internal ledger Not applicable Withdrawal release and custody signer Insider and privileged job paths

9. Conceptual Data Objects

This section lists what each object needs. It defines no wire format. A future revision or a chain-specific profile could specify canonical serialization (for example JSON canonicalization [RFC8785]), signature suites, and encodings. The field names are illustrative.

Candidate Act descriptor
act_id; chain_id; transaction type; resolved target and effective callee chain (including delegatecall targets); value; asset and token contract; calldata digest and decoded function; beneficiary set; code hash of each executed or delegated contract; account state version (nonce, balance); delegation designator state for the source account; requested time; originating workload identity.
Authority Envelope
Reference to the descriptor digest; issuer identity; policy epoch; maximum value and cumulative budget; beneficiary set; allowed code hashes; validity window (not-before, not-after); maximum consumption count; sink identity; nonce or counter; reservation identifier; issuer authenticator.
Reservation
Reservation id; act id; amount; ledger scope (wallet, global, or asset); state (RESERVED, COMMITTED, RELEASED); expiry; reconciliation owner.
Receipt
act_id; envelope reference; observed phase and result (for example SIGNED_NOT_BROADCAST, BROADCAST_PENDING, CONFIRMED, REVERTED, REPLACED, DROPPED, REORGED); transaction hash and nonce; confirmation depth; sink identity; sink-local counter; timestamp; authenticator. A Receipt MAY be required before a later phase of a multi-step operation.

Much of this can be built from existing primitives: threshold signatures [RFC9591], remote attestation [RFC9334], and typed-data signing [EIP-712]. The document does not claim novelty for those primitives individually. Its subject is the integrated invariants in Section 7.

10. State Machine and Crash Discipline

The state machine separates intent, validation, signing, broadcast, and confirmed effect. A wallet or exchange MUST NOT infer actual effects from a memo or endpoint name.

Table 5: Candidate Act states
State Meaning Allowed next states and rule
PROPOSED Request received; no staging yet STAGED_NON_EFFECTIVE, DENIED
STAGED_NON_EFFECTIVE Candidate Act reconstructed; no effect VALIDATED, DENIED; expires
VALIDATED Policy passed; budget not yet reserved SIGNING_RESERVED, DENIED
SIGNING_RESERVED Exposure reserved atomically; authority issued SIGNED_NOT_BROADCAST, or release on explicit abort
SIGNED_NOT_BROADCAST Signature produced; transaction not yet public BROADCAST_PENDING; signature is itself a consequential release
BROADCAST_PENDING Submitted; outcome unknown CONFIRMED, REVERTED, REPLACED, DROPPED, RECONCILIATION_REQUIRED
CONFIRMED Included at required depth for this chain Terminal; authority consumed; reservation committed
REVERTED Included but failed; fee and nonce effects remain Terminal; reservation released after reconciliation
RECONCILIATION_REQUIRED Outcome uncertain (timeout, reorg, crash) CONFIRMED, REVERTED, or bounded manual resolution; no new authority meanwhile
DENIED Policy failed or authority absent, stale, or mismatched Terminal; no effect

A successful broadcast is not proof of confirmed settlement, and a receipt is not proof of finality under reorganization. Confirmation depth MUST follow the chain's consensus assumptions. A transaction that reverts can still cost fees and consume a nonce. Each transition has a defined authority, expiry, and idempotency rule. Consumption of authority and reservation MUST be durably recorded before the signature is released, and INDETERMINATE outcomes MUST be resolved by querying authoritative state, never by issuing fresh authority.

11. Exposure Ledger and Bounded Authority

11.1. Reserve, Commit, Release

A per-transaction limit does not stop an agent from splitting a large theft into many small transfers. The system keeps a protected cumulative ledger and reserves exposure atomically before any signature. Reservation states are RESERVED, COMMITTED, and RELEASED. A reservation MUST be held through uncertain broadcast outcomes. Releasing it early lets a retry spend the same budget twice (Section 19.18).

Table 6: Example synthetic predicates and failure responses
Predicate Example policy Failure response
Asset One stablecoin only Deny other tokens
Beneficiary Allowlisted treasury account Hold new address
Per operation At most 100 units Deny 101
Rolling window At most 300 units per hour Deny aggregate excess
Global cap At most 400 units across all chains Deny aggregate excess on any chain
Delegate Pinned code hash Hold code change
Time Five-minute expiry Require new authority

11.2. Ledger Scope

  • Multiple agents MUST share one ledger. Agent A reserving 400 and Agent B reserving another 400 against a 500 limit MUST NOT both succeed.
  • The ledger MUST be chain-agnostic where policy intent is global. Per-chain ledgers allow a split across chains to exceed the global cap (Section 19.2).
  • Valuation of non-stable assets for USD-denominated caps MUST use a protected price source with bounds, or caps SHOULD be expressed in asset units (Section 19.17).
  • Rolling windows MUST use a protected monotonic clock source, with defined behavior at window boundaries, daylight-saving transitions, and clock skew.

12. EIP-7702 Delegation Controls

12.1. Mechanics Relevant to Defense

EIP-7702 [EIP-7702] lets an externally owned account designate executable code through a signed authorization tuple containing a chain identifier, a delegation target address, and a nonce. A transaction carrying an authorization list installs a delegation designator on the account, so the account's own address then runs the delegated code. The delegation persists until replaced, and pointing it to the zero address clears it. The specification warns that poorly designed delegate contracts can allow near-complete control of the account, and it identifies replay protection and binding of value, gas, target, and calldata as security considerations.

Points that matter for defenders:

  • The authorization is a signature. Anyone can submit it, so the submitting address need not be the account owner, and an attacker who can obtain a valid signature can have it relayed from elsewhere.
  • An authorization may carry chain identifier zero, which the specification allows to apply on any chain. That widens the effect of one signature.
  • The authorization nonce must match the account's live nonce. A signer that produces authorizations for a range of nonces gives an attacker several chances for one to match.
  • Delegated code runs in the account's own context and storage. Re-delegation to different code can collide with storage left by earlier code.
  • Checks that assume an account has no code, or that assume the transaction origin equals the caller, may behave differently for delegated accounts.
  • Delegation and later execution are separate phases. A protected design must assess both.

12.2. Defensive Design

  1. Treat authorization to delegate as a high-risk Candidate Act distinct from any later transfer.
  2. The protected signer MUST NOT sign an EIP-7702 authorization unless the descriptor matches an approved delegation act (R8). It MUST NOT sign speculative nonce ranges.
  3. Resolve the actual delegation address from the bytes and verify its code hash, upgradeability, chain scope (including chain identifier zero), nonce, initialization call, account state, intended permissions, and revocation path.
  4. Reject delegation to unknown or mutable code. Where a proxy is unavoidable, pin the implementation hash, govern upgrade rights, and monitor.
  5. After delegation, enforce per-effect limits inside the delegated implementation or through a mandatory upstream signer. Do not assume the delegation signature enforces downstream spend limits.
  6. Pre-authorize a tested revocation path: an authorization that points the account back to the zero address, plus key rotation and sweep procedures (Section 23).
  7. Monitor accounts for unexpected delegation designators and alert on any change.

The on-chain network cannot consult an off-chain Finality Sink unless the delegated contract is explicitly written to require cryptographic proof or to enforce its own policy. If an attacker already holds the private key and can sign and submit an authorization directly, an off-chain policy cannot prevent it (Section 19.1).

13. Signing-Surface Hazards

Misleading presentation
A compromised front end can show a familiar destination and description while the bytes change a wallet implementation or grant privileged execution. A second copy of the same compromised front end is not a defense. Use independently sourced payload decoding, known-contract registries, a protected hardware display where feasible, and signer-enforced transaction hashes. Signers should approve a canonical rendering derived from the exact payload, and the protected signer should refuse if the code hash, call target, storage effects, or transfer envelope differ from policy.
Blind signing
Signing an opaque hash or typed data without decoding it is a consequence-blind act. Clear signing, structured typed data [EIP-712], and signer-side decoding reduce the risk. Typed-data permits can grant spending authority without a transaction.
Allowances and permits
An ERC-20 approval or a signed permit can authorize later spending without a fresh owner signature. A policy that checks only immediate outflow misses the authority transfer. Approvals and setApprovalForAll-style grants are Protected Consequences (R7).
Address poisoning and lookalike destinations
Attackers seed histories with lookalike addresses so an operator copies the wrong one. Beneficiary binding MUST use full-address allowlists and MUST NOT rely on prefix and suffix matching or history.
Name resolution
A human-readable name can resolve to a different address later. Policy MUST bind the resolved address at decision time and recheck at the sink.
Multisignature workflow
A multisig satisfies a threshold over bytes. It does not by itself verify the economic effect of an arbitrary contract call. Do not assume a generic hardware wallet or multisig verifies the effect.

14. Custody Models and Operational Trade-Offs

Hot wallets favor availability and automated throughput. Cold wallets favor key isolation and deliberate authorization. Both can suffer semantic authorization failures if a signer approves malicious bytes, and the right control placement differs.

Table 7: Primary enforcement and operational concern by custody architecture
Architecture Primary enforcement Operational concern
Hot-wallet exchange Signer and withdrawal release; rolling budgets Latency, throughput, batching; blast radius if key leaks
Cold multisig Trusted payload rendering and contract policy Semantic display integrity; slow response
MPC custody Quorum policy and share release Collusion and shared policy failures; policy expressiveness
HSM-backed signer Policy engine adjacent to the HSM HSM signs what the builder sends unless it decodes
Smart-account treasury On-chain policy module Upgrade authority and delegate security
EOA with direct key Wallet signer only Cannot stop externally submitted valid signatures

For hot wallets, combine protected signer policies, rolling exposure budgets, per-beneficiary controls, code and delegate checks, withdrawal queues, and emergency circuit breakers. For cold wallets, use trusted transaction rendering, separated approvals, independent payload reconstruction, delayed high-risk upgrades, and verified on-chain settlement receipts.

A policy that freezes every routine withdrawal becomes operationally unacceptable and invites bypass. Tiered controls are RECOMMENDED: low-risk known-destination transfers receive deterministic fast checks; new beneficiaries, contract upgrades, delegation changes, and high-value transfers receive stricter verification and possibly timelocks.

Large hot-wallet fleets deserve extra caution. If many wallets share one key-derivation root, one signing service, or one deploy pipeline, a single compromise reaches all of them at once. Spreading risk across independent signers and capping per-wallet balances limits blast radius.

15. Independence and Shared-Failure Analysis

Independence is an architectural property. A second process with the same administrator, credentials, and deploy pipeline is not independent. The policy evaluator SHOULD receive independently attested context, while the signer or wallet enforces the resulting narrowly scoped decision.

Consider separate key domains, protected policy storage, quorum-based policy updates, attested signer binaries, anti-rollback versioning, independent code-hash verification, and key release only after validation. Do not let an administrator of the transaction builder modify both policy and signing logic.

Independence fails if the attacker compromises a common kernel, a shared CI/CD system, a hypervisor, a root cloud account, or a wallet upgrade authority. Deployments MUST therefore document shared-failure analysis explicitly and MUST NOT claim absolute non-bypassability.

Table 8: Common-mode failure checklist
Shared element Question to answer
Administrator or identity provider Can one account change policy, validator, and signer?
CI/CD and build signing Can one pipeline ship altered signer or validator binaries?
Cloud root account or hypervisor Can one control plane read keys or edit policy state?
Key hierarchy Do policy keys and signing keys share a root?
Upgrade authority Can one party replace the on-chain policy module?
Monitoring and audit Can the same attacker silence all evidence channels?

16. AI Agents, MCP, and Delegated Tools

A custody assistant may legitimately read balances, prepare transactions, and query risk limits. It MUST NOT inherit authority to finalize withdrawals. Tool discoverability, successful authentication, and valid arguments do not constitute transfer authority. Permission to prepare an operation is not permission to finalize it.

17. Cross-Chain, Bridge, Stablecoin, and Allowance Hazards

An apparent transfer can be implemented as a token transfer, approval, permit, delegated call, bridge lock, mint, swap, or multicall. The final effect can differ from the visible top-level function, so policy must account for transitive effects and stateful approvals.

Table 9: Operations with hidden downstream consequences
Operation Hidden consequence Proposed gate
approve or permit Future third-party spend Allowance cap and spender review
delegatecall Code executes in the wallet's context Pinned code and storage-effect policy
bridge lock or release Cross-chain mint or release Dual-side proof, limits, and finality depth
swap or intent Variable execution route and price Slippage, destination, and token bounds
multicall Composition of effects Evaluate full-call semantics, not the first call
token hooks or callbacks Reentrant or side-effecting transfers Treat hooks as part of the Candidate Act

Bridge transfers need matching source-chain lock and destination-chain release evidence, with reorganization and finality assumptions stated. Stablecoin issuers may offer pause or freeze functions, but availability and legal authorization vary. A sink MUST NOT assume every token can be frozen or clawed back after settlement.

18. Edge Cases

These cases test whether an implementation holds its invariants at the boundaries. Each states the hazard and the required handling.

18.1. Chain and Settlement Edge Cases

EC1. Reorganization after confirmation
A transaction seen as confirmed is removed or reordered. Keep exposure reserved until the chain-appropriate finality depth. Do not consume authority or release the reservation on a shallow confirmation. Re-run reconciliation after any reorganization signal.
EC2. Replacement transaction (same nonce)
A fee-bumped or cancel transaction replaces the original. Track transaction identity per nonce. If a replacement confirms, the original is REPLACED and its reservation resolves against the replacement's actual effect, which may differ from the original Candidate Act. Treat a replacement as a new Candidate Act when its bytes differ.
EC3. Dropped transaction
A pending transaction vanishes from the mempool. Do not assume failure. Query nonce and receipt state, then decide. Keep the reservation until the nonce is known to be consumed elsewhere or the transaction cannot still confirm.
EC4. Nonce gaps and stuck queues
An earlier stuck transaction blocks later ones. Resolving it by cancelling or replacing is itself a consequential act and passes the gate.
EC5. Fee spikes and failed execution
A reverted transaction still burns fees and consumes the nonce. Reservation accounting MUST include fee exposure and MUST NOT treat a revert as zero effect.
EC6. Private relays and alternate broadcast
A signed transaction can be sent through any relay, including private ones, at any later time. The signature is the consequential release, so the gate sits before signing, and signed-but-unbroadcast transactions are tracked with expiry (for example by validity windows or by nonce invalidation).
EC7. Layer-2 sequencer outage and forced inclusion
When a sequencer is down, users may force inclusion through the base layer, with different timing and ordering. Reconciliation MUST understand each route's finality and MUST NOT assume a single path to settlement.
EC8. Hard forks and chain splits
A fork can make one transaction valid on two chains. Chain identifiers bind a signature to one chain, except an authorization using chain identifier zero, which applies broadly. Policy SHOULD reject chain-identifier-zero authorizations unless explicitly approved.
EC9. Bridge finality mismatch
A destination chain mints before the source chain is final. Require source-finality depth before authorizing the destination effect, and cap per-window bridge exposure.

18.2. Asset and Token Edge Cases

EC10. Fee-on-transfer, rebasing, and elastic-supply tokens
The amount received or held differs from the amount in calldata. Bind caps to the effective balance change observed in simulation and verify after settlement, not only to the argument.
EC11. Upgradeable and blacklistable tokens
Token logic can change, or a token can freeze the destination. Pin token implementation hashes for covered assets, and treat issuer-side freezes as external events, not as protection.
EC12. Hooks and reentrancy
A token or recipient executes code during transfer. Include callee code and hooks in reconstruction, and set gas and call-depth limits so a hook cannot trigger an unreviewed second effect.
EC13. Dust and many-small-transfer attacks
Many tiny transfers evade per-transfer thresholds or flood the validator. Aggregate by identity, destination, and window, and apply admission control.
EC14. Valuation and volatility
A USD cap on a volatile asset can be exceeded by price movement or oracle manipulation. Prefer unit caps for volatile assets, or use bounded, protected price sources with deviation limits.
EC15. Multi-asset multicall
One call moves several assets. The cap is applied per asset and in aggregate, using the effective effects from simulation plus a post-state check where the substrate allows.

18.3. System and Operations Edge Cases

EC16. Validator timeout, split brain, duplicate act identifiers
Two validator replicas decide the same act differently or a client retries with the same act_id. Authority is issued by a single linearizable source per ledger scope, and the sink rejects a second consumption of one act_id.
EC17. Crash between consumption and confirmation
The sink records consumption, then fails before the signature or broadcast confirmation. On restart the act is INDETERMINATE. Resolve by querying authoritative state. Do not re-issue authority.
EC18. Policy rollback and downgrade
An older, validly signed policy is replayed to raise caps. Enforce monotonic policy epochs at the validator and sink. A downgrade requires an explicit, quorum-approved, logged procedure.
EC19. Key rotation mid-flight
Authority issued under an old key or epoch arrives after rotation. Authority carries the epoch, and a sink rejects authority from a retired epoch. Pending acts are re-evaluated under the new epoch, not silently honored.
EC20. Clock skew, daylight-saving, and window boundaries
Rolling windows and expiries depend on time. Use a protected monotonic source, define behavior at boundaries, tolerate bounded skew in one direction only (never extending a window), and test around transitions.
EC21. Break-glass during an incident
Emergency paths are needed and are an attack surface. Require dual control, a small budget, a timelock where safe, and independent logging, and test them regularly.
EC22. Validator outage under load
An outage creates pressure to disable the gate. Keep a routine local fast path with signed policy and protected local counters, hold high-risk effects, rate-limit, and define an authorized degraded mode in advance.
EC23. Insider with policy-administration rights
A single administrator approves theft. Separate governance from signing, require quorum for policy changes, and log changes to an independent record. Test common-mode compromise.
EC24. Legacy wallets that cannot host a module
Where an old wallet cannot enforce on-chain policy, move funds to a wallet that can, or place a mandatory protected signer in front, and record the residual risk until migration finishes.
EC25. Legal or regulatory holds
A court or regulator may require freezing or release. These are separately authorized acts and MUST pass the same gate with their own authority and evidence, not a side door.

19. Threat Scenario Catalogue

Each scenario states the attack, why conventional controls can miss it, the proposed mitigation, the residual risk, and the test. Scenarios are illustrative and synthetic. Where a scenario resembles a reported incident, that is for motivation only, and no claim is made about the actual incident trace. Scenario identifiers T1 to T24 are referenced by the simulator in Appendix A where one exists (S01 to S14).

19.1. T1: Leaked Hot-Wallet Key and Delegation to an Attacker Sweeper

Attack
An attacker holds signing capability for a hot wallet, signs an EIP-7702 authorization delegating the account to a sweeper contract, has it relayed from another address, then drains assets in minutes.
Why conventional controls miss it
The signature is valid. Transfer-focused policy does not see a delegation as a transfer. If the key signs offline and submits directly, no off-chain gate is consulted. Monitoring sees it after settlement.
Mitigation
Keys non-exportable, so signing happens only inside the protected signer, which refuses unapproved delegation authorizations (R8). For EVM wallets, move custody to smart accounts or delegated policy modules whose limits the key cannot bypass. Cap per-wallet balances to bound blast radius.
Residual risk
If the raw key is exfiltrated and the account stays an unrestricted EOA, the off-chain layer cannot stop direct submission (S14). Only the on-chain mandatory rule or key non-exportability helps.
Test
S05, S07, S14; add a test that the signer refuses a delegation authorization with a valid but unapproved target.

19.2. T2: Parallel Multi-Chain Drain

Attack
Withdrawals are launched on several chains at once, each below its own cap, so the sum exceeds the organization's intent.
Why conventional controls miss it
Per-chain counters do not see the global total. Chains without smart-account features cannot enforce on-chain rules at all.
Mitigation
A single chain-agnostic Exposure Ledger and a global cap. For non-programmable chains the gate is at the signer and release layer.
Residual risk
Ledger availability and integrity become critical. Compromise of the ledger voids the cap.
Test
S08.

19.3. T3: Compromised Signing Interface Misleading Multisig Signers

Attack
A compromised interface shows signers a familiar destination while the signed bytes change a wallet implementation or call. A valid threshold approves.
Why conventional controls miss it
The threshold is satisfied by legitimate signers over what they were shown.
Mitigation
Independent decoding of the bytes, a canonical rendering from a separate trusted source, protected hardware display where feasible, signer-enforced digests, and refusal when code hash, target, or storage effects differ from policy (R1).
Residual risk
If the decoder or the trusted display shares the compromised path, it fails.
Test
S05 (substitution of target while displaying an approved one).

19.4. T4: Induced Delegation to Malicious or Mutable Code

Attack
A phishing or compromised workflow persuades an owner to sign a valid delegation to attacker-controlled code, or to a proxy whose implementation changes after approval.
Why conventional controls miss it
The signature is genuine. Address allowlists check the address, not the code behind it.
Mitigation
Pin the code hash. Reject unknown or mutable delegates. Govern upgrade rights. Enforce per-call limits inside the delegate or through a mandatory signer.
Residual risk
A trusted, audited delegate with its own bug.
Test
S05, S06.

19.5. T5: Speculative Authorization Batch Over a Nonce Range

Attack
A compromised builder asks the signer for many delegation authorizations covering a range of account nonces, so that at least one matches the live nonce when submitted.
Why conventional controls miss it
Each request is an individually valid, well-formed signing request. Request counts may be low.
Mitigation
The signer refuses any delegation authorization without an approved act (R8), and refuses multi-nonce batches. Alert on repeated requests for future-power signatures.
Residual risk
None if the signer is Mandatory. Total if the key signs elsewhere.
Test
S07. This scenario is a test case; the reported nonce-range explanation for the October 2026 incident is unconfirmed.

19.6. T6: Split Withdrawals Below Per-Transaction Limits

Attack
One large theft is cut into many small transfers across workers, each under the per-transaction cap.
Why conventional controls miss it
A signer enforcing only a per-transaction cap approves all of them.
Mitigation
Protected cumulative ledger, atomic reservation, beneficiary allowlist.
Residual risk
Slow, below-threshold drains to an allowlisted beneficiary that has itself been compromised.
Test
S01, S02, S03.

19.7. T7: Allowance and Permit Drain

Attack
A signer is induced to grant a large allowance or sign a permit to an attacker spender, who later pulls funds without a new signature.
Why conventional controls miss it
No funds move at signing time, so transfer policy passes it.
Mitigation
Treat approvals and permits as Protected Consequences (R7): cap, spender allowlist, expiry. Review and revoke existing allowances.
Residual risk
Allowances issued before the gate existed remain exploitable until revoked.
Test
S12.

19.8. T8: Hidden Effects Through Multicall, Delegatecall, and Hooks

Attack
The top-level call looks benign while a nested call, a delegatecall into attacker code, or a token hook moves value or changes state.
Why conventional controls miss it
Policy reads the first function name or a simulation that does not follow hidden dependencies.
Mitigation
Reconstruct full call semantics and callee code hashes, treat hooks as part of the act, and apply post-state checks where available.
Residual risk
Simulation that diverges from execution because of state or ordering changes.
Test
Add a vector with nested transfer and delegatecall into an unpinned contract.

19.9. T9: Bridge Release and Finality Mismatch

Attack
A destination-chain release is triggered by a source-chain event that is later reorganized, or an alternative bridge executor bypasses the verifier.
Why conventional controls miss it
The release is valid against the evidence available at the time.
Mitigation
Dual-side proof, finality-depth requirements, per-window bridge caps, and a single mandatory release executor.
Residual risk
Consensus failure on either chain.
Test
Reorganization vectors for EC1 and EC9.

19.10. T10: Upgrade-Admin Takeover Replacing the Policy Module

Attack
The attacker obtains upgrade authority and replaces the on-chain policy module or proxy implementation.
Why conventional controls miss it
The upgrade is authorized by the very authority the policy trusts.
Mitigation
Timelock, independent veto, quorum approvals, code-hash verification, and monitoring of upgrade events.
Residual risk
Compromise of every party in the quorum.
Test
Attempt an unapproved upgrade and measure time to detect and veto.

19.11. T11: Insider or Policy Administrator Approves Theft

Attack
A single administrator edits policy to allow an attacker beneficiary and then requests transfers.
Why conventional controls miss it
The change is made with legitimate rights.
Mitigation
Quorum-signed policy, separation of governance from signing, mandatory waiting period for new beneficiaries, independent logging.
Residual risk
Collusion across the quorum.
Test
Common-mode compromise test (EC23).

19.12. T12: Compromised Validator or Signer Fabricates Approval

Attack
An attacker controls the Protected Validator or the sink and issues authority for any act.
Why conventional controls miss it
Not applicable: this defeats the proposal.
Mitigation
Attestation, constrained keys, quorum, separation, independent audit. These reduce likelihood, not eliminate it.
Residual risk
High. The architecture can fail here, and the document says so.
Test
Negative control: report the failure honestly.

19.13. T13: Break-Glass and Emergency Signer Abuse

Attack
Stolen help-desk or operator credentials invoke the emergency signer for an urgent transfer to a new address.
Why conventional controls miss it
Emergency paths are designed to bypass normal controls.
Mitigation
Dual control, small budget, timelock, independent logging, and regular drills (R14).
Residual risk
Two credentials compromised at once.
Test
S13.

19.14. T14: Prompt-Injected AI Agent Requests a Withdrawal

Attack
Content the agent reads instructs it to widen a transfer or change a beneficiary, and the agent submits a request with valid credentials.
Why conventional controls miss it
The request is authenticated and well-formed.
Mitigation
The sink takes authority only from protected policy, never from model text or tool output. Agent-to-agent delegation attenuates. Preparation is separate from finalization.
Residual risk
Policy that is itself too broad.
Test
Inject instructions into the agent's input and confirm no effect without act-bound authority.

19.15. T15: Phishing to Cloud Account to Treasury Instruction

Attack
A phished staff credential reaches a cloud suite used for treasury approvals. The attacker sets mail-forwarding rules, grants application consent, or alters a treasury instruction that a custody workflow then acts on. This is a hypothetical chain; public evidence does not show it occurred in any observed campaign.
Why conventional controls miss it
Phishing-resistant authentication and conditional access may already stop several steps. Where one is bypassed, a valid session does not show that a new forwarding recipient, consent, or beneficiary is authorized.
Mitigation
Out-of-band confirmation of beneficiary changes, a mandatory waiting period for new beneficiaries, custody release bound to an independently stored instruction (not a mailbox), and the same gate at each separate consequence.
Residual risk
The gate cannot prevent the click or the password entry. It begins when the compromised identity attempts a consequence in defender-controlled systems.
Test
Walk the chain with a synthetic identity and verify each consequence is separately gated.

19.16. T16: Address Poisoning

Attack
Lookalike addresses are seeded into history so an operator copies the wrong beneficiary.
Why conventional controls miss it
The destination looks familiar to humans and may pass prefix or suffix checks.
Mitigation
Full-address allowlists, no reliance on history, waiting period for new addresses.
Residual risk
An operator adding the wrong address to the allowlist itself.
Test
Lookalike vectors against the allowlist.

19.17. T17: Valuation and Oracle Manipulation of Caps

Attack
A USD-denominated cap on a volatile or thin asset is exceeded by manipulating the price source or by market movement.
Why conventional controls miss it
The cap is satisfied numerically.
Mitigation
Unit caps for volatile assets, bounded protected price sources, deviation limits, and a separate cap on count of operations.
Residual risk
Source compromise.
Test
Price-shock vectors against the cap logic.

19.18. T18: Retry or Reorganization Spending the Same Budget Twice

Attack
A transfer is broadcast, confirmation is delayed, an agent retries, and the original later confirms as well. Or a reorganization removes a confirmed transfer and the budget has already been released.
Why conventional controls miss it
Systems that release budget on timeout sign a second transaction with fresh authority.
Mitigation
Hold the reservation through uncertainty, track act id, transaction id and nonce, reconcile by chain state, and deny retries with new authority until resolved.
Residual risk
Unbounded INDETERMINATE exposure if reconciliation is slow. Report maximum unresolved exposure.
Test
S04.

19.19. T19: Validator Denial of Service to Force Fail-Open

Attack
The attacker floods or disables the validator so the business disables the control to restore throughput.
Why conventional controls miss it
Fail-open policy engines release when unavailable.
Mitigation
Fail closed for high-risk effects, a local fast path for routine ones, admission control, capacity planning, and a defined degraded mode that does not silently open.
Residual risk
Availability loss for non-routine operations during an attack.
Test
S10.

19.20. T20: Supply-Chain Compromise of the Signer or Validator Build

Attack
A malicious update ships through the build pipeline and weakens validation or leaks keys.
Why conventional controls miss it
The update arrives through a trusted channel.
Mitigation
Measured or attested images, reproducible builds, separate signing authority for releases, quorum for updates, anti-rollback.
Residual risk
Compromise of the release authority.
Test
Attempt to install an unsigned or older version and confirm rejection.

19.21. T21: Social Engineering of Recovery, Rotation, or Help Desk

Attack
An attacker persuades support to reset credentials, rotate a key to one they control, or enroll a new signer.
Why conventional controls miss it
The process is legitimate and the requester appears legitimate.
Mitigation
Treat signer enrollment and key rotation as Protected Consequences with quorum, waiting periods, and out-of-band confirmation.
Residual risk
Quorum members socially engineered together.
Test
Tabletop and red-team enrollment attempts.

19.22. T22: Stale Policy Bundle Replay

Attack
An older, validly signed policy with higher limits is replayed to the validator or sink.
Why conventional controls miss it
The signature on the old bundle is valid.
Mitigation
Monotonic policy epochs enforced at validator and sink, with rollback only through a logged quorum procedure.
Residual risk
Epoch store compromise.
Test
S11.

19.23. T23: Cross-Chain Replay of a Broad Authorization

Attack
One signed authorization using chain identifier zero, or one signature reused across forks, is submitted on every chain where the account exists.
Why conventional controls miss it
One signature appears to apply to one intent.
Mitigation
Bind chain identifier in every authority, reject chain-identifier-zero authorizations unless explicitly approved, and track per-chain nonce state.
Residual risk
Chains with different replay semantics.
Test
Submit an approved single-chain authorization on a second chain and expect rejection.

19.24. T24: Customer Account Takeover Withdrawing to a New Address

Attack
A taken-over customer account requests withdrawal of the whole balance to a new address.
Why conventional controls miss it
The session and second factor may be the attacker's.
Mitigation
New-address waiting period, per-customer rolling limits enforced at the release boundary, out-of-band confirmation, and the same effect-bound check used for treasury flows.
Residual risk
Customer friction trade-offs.
Test
Synthetic takeover with whole-balance withdrawal to a new address.

20. Simulation and Evaluation Method

This section describes how to evaluate the architecture and how to read the reference simulator in Appendix A. Expected outcomes are test hypotheses. The simulator is a model of policy logic and accounting. It is not a chain, wallet, or exchange, and its results are not evidence of real-world prevention.

20.1. Three Configurations

Every experiment MUST run in three configurations, to avoid a weak baseline:

  • Arm A: an ordinary signer with coarse identity and access control.
  • Arm B: strengthened conventional custody controls (MPC or HSM policy, allowlists, per-transaction and rolling caps, timelocks, simulation, monitoring).
  • Arm C: Arm B plus the independent, effect-bound enforcement described here.

The security benefit is the difference between Arm C and Arm B, not between Arm C and Arm A.

20.2. Rules for Real Experiments

  • Use synthetic assets on local test chains or public testnets. Never use live production funds.
  • Pre-register expected pass and fail conditions before testing.
  • Collect transaction hashes, policy versions, attestation evidence, signed bytes, decoded calldata, code hashes, destination and amount, reservation state, validator decision, latency distribution, and chain receipt.
  • Include negative controls in which the mechanism is bypassed or compromised, and report the failures.
  • Record whether the unauthorized effect actually occurred, not only whether a policy engine returned DENY.

A successful result demonstrates a property under a defined threat model. It does not establish universal protection, legal compliance, novelty, or prevention of any historical breach.

20.3. Simulator Scenarios and Threat Mapping

Table 10: Reference simulator scenarios mapped to catalogue threats
Simulator Scenario Threat
S01 Split withdrawal, unauthorized beneficiary T6
S02 Split withdrawal, authorized beneficiary, aggregate cap T6
S03 Concurrent race on rolling cap (stale counter) T6, T2
S04 Retry during uncertain settlement T18
S05 Delegation target substitution T3, T4, T1
S06 Mutable-proxy delegate changed after approval T4
S07 Builder requests 50 delegation authorizations T5, T1
S08 Four-chain parallel drain versus global cap T2
S09 Replay of one approval three times T22, general replay
S10 Validator outage, mixed workload T19
S11 Stale policy bundle replayed T22
S12 approve or permit to attacker spender T7
S13 Break-glass abuse with one stolen credential T13
S14 Raw key leaked, direct chain submission T1 (limit)

Threats T8 to T12, T14 to T17, T20, T21, T23, and T24 need chain-level or organizational tests that the model does not cover. They are listed with a test in Section 19.

21. Latency and Throughput Engineering

Do not put heavyweight approval in every token-generation step or blockchain polling loop. Enforce at high-consequence signing and effectuation transitions. Precompute trusted policy, maintain local protected counters, and use deterministic cryptographic verification for low-risk operations. The goal is not zero overhead. It is a measured trade-off that does not push operators to disable the control.

Table 11: Workload tiers and measurements
Workload Approach Measurement
Routine withdrawal to known beneficiary Local signed policy and counter p99 gate latency
New beneficiary Enhanced review and delay Time to safe release
Contract upgrade or delegation change Multi-party approval and timelock Unmediated upgrade attempts
Mass agent requests Atomic global budget Overspend under concurrency
Validator outage Hold high-risk effects; fast path for routine Availability and recovery time

Suggested metrics: p50, p95, and p99 gate latency; approvals per second; maximum reservation contention; false-hold rate; validator outage behavior; queue recovery time; reorganization reconciliation lag; and the percentage of protected effects reachable without mediation. No measured latency is reported in this document, and the simulator does not measure it.

22. Deployment Roadmap

  1. Inventory and consequence mapping: enumerate every wallet, key, signer, contract, upgrade path, batch executor, RPC route, allowance, bridge, emergency credential, and administrator that can produce a protected financial effect. Build a path-to-effect graph and mark each unmediated route.
  2. Enforce bounded authority: choose enforceable signer and on-chain boundaries, bind the canonical operation, beneficiary, chain, amount, delegate code, time, and epoch, and stand up the shared Exposure Ledger and non-replayable authorization.
  3. Observe-only mode: run the validator beside production, compare its decisions with actual outcomes, tune policy, and measure false holds. Do not enforce yet.
  4. Enforce by consequence class: begin with delegation and approvals, new beneficiaries, and upgrades, then high-value transfers, then routine flows, each with a rollback path.
  5. Independence and resilience: separate policy administration from construction and custody, test fail-closed behavior, emergency recovery, signer replacement, upgrades, and reorganization handling.
  6. Test and measure: run the synthetic scenarios, compare against strengthened conventional controls, publish measured latency and failure results, and refine coverage before wide rollout.

Compatibility: some designs work through a protected signer or an on-chain module. Others need wallet or contract changes and cannot be retrofitted transparently.

23. Operations: Revocation, Recovery, and Monitoring

Detection and revocation of a bad delegation
Monitor accounts for delegation designators and alert on change. Keep a rehearsed procedure that signs an authorization pointing the account back to the zero address, rotates the key, and sweeps funds to a safe wallet. Public reports of the October 2026 incident describe a delegation remaining unrevoked for more than two hours, which illustrates why this procedure should be prepared in advance.
Circuit breakers
Automatic halts on anomalies: unexpected delegation, spend above rolling thresholds, repeated denied attempts, validator disagreement. Breakers MUST fail toward holding high-risk effects.
Incident freeze
A quorum-approved action that freezes relevant envelopes, revokes pending authority, and prevents queued operations from draining under stale approvals.
Key rotation and recovery
Rotation and signer enrollment are Protected Consequences with quorum, waiting periods, and out-of-band confirmation (T21). Pending acts are re-evaluated under the new epoch.
Allowance hygiene
Periodically list and revoke unneeded allowances and delegations, and cap new ones.
Independent evidence
Decisions, receipts, and policy changes are written to a record the builder cannot alter. Evidence supports investigation, accountability, and supervisory review, and does not by itself determine legal liability.

24. Falsifiable Acceptance Criteria

Table 12: Pre-registered acceptance criteria for real experiments
Metric Acceptance criterion
Unauthorized transfers Zero in protected, tested paths
Aggregate overspend Zero above the atomic budget, including under concurrency
Replay At most one effective act per bound nonce
Delegate substitution 100 percent of test substitutions rejected
Unapproved delegation authorizations signed Zero
Bypass coverage All enumerated protected paths mediated
False denials on a legitimate mix Reported empirically against a stated target
p99 latency Reported empirically, not presumed
Compromised root key or upgrade admin Explicit limitation disclosed

The strongest falsification tests are: demonstrate a protected high-value transfer through an unmediated route, or a budget breach under concurrent requests. Either one shows the claim does not hold for that deployment.

25. Limitations

26. Security Considerations

This entire document concerns security. Further points:

27. Privacy Considerations

Candidate Act descriptors, ledgers, and Receipts can reveal balances, counterparties, and operational patterns. Operators SHOULD minimize retained detail, protect these records, apply retention limits consistent with applicable law, and avoid publishing wallet addresses or limits in ways that help attackers.

28. IANA Considerations

This document has no IANA actions.

29. References

29.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.

29.2. Informative References

[EIP-712]
Ethereum Improvement Proposals, "EIP-712: Typed structured data hashing and signing", , <https://eips.ethereum.org/EIPS/eip-712>.
[EIP-7702]
Ethereum Improvement Proposals, "EIP-7702: Set Code for EOAs", , <https://eips.ethereum.org/EIPS/eip-7702>.
[FSA-BYBIT]
Financial Services Agency, Japan, "Research paper discussing the February 2025 multisignature wallet interface incident", Verify against the original publication, , <https://www.fsa.go.jp/policy/bgin/ResearchPaper_dtc_en.pdf>.
[INCIDENT-REPORTS]
Various security firms and industry bodies, "Public analyses and fact cards on the 29 October 2026 exchange hot-wallet theft (multiple authors)", Third-party accounts; verify on-chain and against primary sources, .
[MSFT-PHISH]
Microsoft Threat Intelligence, "Notice on phishing campaign exploiting the 12 November 2026 service disruption", Verify against the original publication, .
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/info/rfc8785>.
[RFC9334]
Birkholz, H., Thaler, D., Richardson, M., Smith, N., and W. Pan, "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, , <https://www.rfc-editor.org/info/rfc9334>.
[RFC9591]
Connolly, D., Komlo, C., Goldberg, I., and C. A. Wood, "The Flexible Round-Optimized Schnorr Threshold (FROST) Protocol for Two-Round Schnorr Signatures", RFC 9591, DOI 10.17487/RFC9591, , <https://www.rfc-editor.org/info/rfc9591>.

Appendix A. Reference Simulator and Results

The reference simulator is a short Python program, finality_sim.py, distributed with this draft. It is deterministic, uses synthetic units, and contacts no chain, wallet, HSM, or exchange. It runs with "python3 finality_sim.py" and exits non-zero if an acceptance assertion fails. "python3 finality_sim.py --json" prints machine-readable results.

A.1. How the Arms Are Defined

Results follow from these definitions, so the table checks that the designed logic and accounting behave as specified. It is a regression and acceptance harness. It does not show that real attackers would be stopped.

Arm A
Ordinary signer. Signs anything the possibly compromised builder sends.
Arm B
Strengthened conventional controls. Beneficiary allowlist; per-transaction cap of 100; atomic rolling cap of 300 per chain; signer decodes transfer fields; delegation approved on the displayed description; fail-open on policy-service outage; accepts any validly signed policy bundle; no handling of approvals or delegation authorizations; releases budget on timeout; per-chain counters only. In S03 the rolling counter is read before any worker writes it, modelling a stale read.
Arm C
Arm B plus: reconstruction from bytes with code-hash pinning; atomic reservation across chains held through uncertain outcomes; one-time act-bound authority; refusal of unapproved delegation authorizations; monotonic policy epochs; approvals and permits treated as consequences; fail-closed for high-risk effects with a local fast path for routine ones; break-glass under dual control and a small budget.

Several Arm B weaknesses (per-chain counters, fail-open, no epoch check, release on timeout) are modelling assumptions. Deployments that already close them would see smaller differences. This is why Section 20.1 requires a strengthened baseline in real experiments.

A.2. Results

Table 13: Reference simulator output (synthetic units; model, not a chain)
ID Scenario Metric A B C
S01 Split withdrawal, unauthorized beneficiary units released 900 0 0
S02 Split withdrawal, authorized beneficiary (overspend vs 300 cap) units above cap 600 0 0
S03 Concurrent race on rolling cap (stale counter) units above cap 150 150 0
S04 Retry during uncertain settlement duplicate units 270 90 0
S05 Delegation target substitution (display H1, bytes H2) takeover (1/0) 1 1 0
S06 Mutable-proxy delegate changed after approval takeover (1/0) 1 1 0
S07 Builder requests 50 delegation authorizations (nonce range) takeover (1/0) 1 1 0
S08 Four-chain parallel drain vs global cap units above cap 1760 680 0
S09 Replay of one approval three times replayed units 270 180 0
S10 Validator outage, mixed workload units released 500 500 0
S11 Stale signed policy bundle replayed (epoch 3 vs 5) units above cap 700 700 0
S12 approve()/permit to attacker spender exposure granted 1000 1000 0
S13 Break-glass abuse with one stolen credential units released 500 500 0
S14 Raw signing key leaked, direct chain submission units released 1000 1000 1000

Reading the table: the metric column states what is counted (units released, units above the cap, duplicate units, a takeover flag, or exposure granted). Lower is better. In S03 and S08 the result in Arm B comes from the stale counter and per-chain ledgers described above, which Arm C removes by reserving atomically against one shared ledger. In S08 Arm C still releases 360 units, which is below the 400 global cap, so "units above cap" is zero.

Additional checks: in S10, Arm C blocked 0 legitimate units, because the routine transfers ran on the local fast path while the five high-risk transfers were held. In a separate mix of 100 in-policy transfers, Arm C produced 0 false denials. For S14, a mandatory on-chain module with the same limits (modelled as 300 minus a 30-unit margin) would cap the loss at 270 units, against 1000 when only an off-chain gate exists.

S14 is a documented limit. When a leaked key submits directly to an unrestricted account, all three arms lose the full balance. This result is intended: the document states that an off-chain gate cannot stop it.

A.3. Extending the Simulator

To move from a model to evidence, replace each scenario function with a harness against a local test chain (for example a forked development node) and a real signer, record the items listed in Section 20.2, and keep the acceptance assertions unchanged. Add vectors for the threats the model does not cover (T8 to T12, T14 to T17, T20, T21, T23, T24).

Appendix B. Frequently Asked Questions

The answers describe proposed design patterns and conditions for enforceability. They are not deployed or empirically validated results.

B.1. Basics

Q1. Does this replace multisig, MPC, or HSMs?
No. Multisig distributes signing authority, MPC and HSMs protect keys, and the proposed gate adds consequence-specific constraints. They can all be required together.
Q2. Does a valid signature prove a safe transfer?
No. It proves a cryptographic authorization condition, not that the organization intended the actual effect.
Q3. Does the attacker have to implement Candidate Acts or use the gate?
No. The defender constructs the Candidate Act from the effective requested operation. The attacker only sends ordinary requests, and cannot avoid the gate by refusing to use it if the effect has no other route.
Q4. Can an off-chain validator stop a direct transaction from a leaked key?
Not if a valid key can sign and submit unrestricted transactions outside the validator. Protection then needs a non-exportable key or a mandatory on-chain rule, such as a smart-account module.
Q5. Does this eliminate key theft?
No. It aims to limit what compromised credentials can effectuate, where the control is mandatory.
Q6. Does zero trust become obsolete?
No. Identity and session controls remain essential and complement consequence authorization.

B.2. The incidents

Q7. Could this have prevented the reported October 2026 exchange theft?
Not established. Prevention would depend on the actual attack path and on whether a mandatory signer or on-chain wallet policy mediated the delegated action. Reports also describe losses on chains without delegation, so no single mechanism explains the whole event.
Q8. Could this have prevented the February 2025 theft?
Not established. Independent payload reconstruction and signer controls might address some presentation-tampering failure modes, but retrospective prevention is unproven.
Q9. Is EIP-7702 inherently malicious?
No. It enables useful account functionality. Malicious or poorly governed delegation creates risk, and the specification itself warns about it.
Q10. Is an EIP-7702 delegation a one-time approval?
No. It changes the executable behavior of the account until replaced or cleared, subject to the delegate code.
Q11. Why does the paper keep the Bybit and Binance cases separate?
They are different events with different reported mechanisms. Conflating them would create a false technical claim.

B.3. Design questions

Q12. Where is the Finality Sink for a centralized exchange?
At protected withdrawal signing and release, with controls against alternate signing or broadcast paths, and with reconciliation of post-broadcast receipts.
Q13. What is the on-chain Finality Sink?
A mandatory wallet or contract execution rule that rejects effects lacking valid policy-bound authority.
Q14. Where should a code-upgrade gate sit?
At the upgrade authority and execution contract, with independent approvals and a timelock or veto where appropriate.
Q15. Why bind the beneficiary, chain identifier, and code hash?
A valid transfer to an unauthorized destination can be economically irreversible. Chain binding avoids cross-chain authorization confusion and unintended broad delegation. A familiar name or address label does not prove which executable implementation will run.
Q16. Are proxies forbidden?
No, but upgradeability changes the trust model and needs protected governance, pinned implementation hashes, and monitoring.
Q17. Why track rolling budgets and reserve before signing?
To stop many individually small transfers from exceeding aggregate exposure, and to stop parallel requests from each consuming the same unspent budget.
Q18. Can token approvals cause future losses?
Yes. An approval or permit can allow later spending without a fresh owner signature, so it is treated as a consequence.
Q19. Does a transaction receipt prove final settlement?
Not always. Confirmation and finality depend on the chain and on reorganization assumptions.
Q20. What is an evidence-carrying receipt?
A proposed authenticated record that binds a phase and its observed result to the act, used for reconciliation and later authority decisions.
Q21. Can agents just use another RPC endpoint?
If they hold unrestricted signing authority, yes. Mandatory control must sit at the signer or the on-chain execution path.
Q22. What about bridge exploits?
Apply separate source and destination effect gates, require finality depth, cap exposure per window, and reconcile cross-chain outcomes. There is no universal guarantee.
Q23. Can a wallet interface be trusted?
Not alone. Verify the exact bytes and semantics independently of potentially compromised presentation.

B.4. Operations and limits

Q24. What happens if the validator is unavailable?
High-risk effects hold. Routine low-risk transfers can run on a local fast path with signed policy and protected local counters. The mode is defined in advance, and a failure does not silently open.
Q25. Can a compromised policy administrator approve theft?
Potentially. Separate governance from signing, require quorum for policy changes, and test common-mode compromise.
Q26. Can a hot wallet use machine-speed checks?
That is a design goal. Actual performance must be measured under concurrency and failure, and no figure is claimed.
Q27. What if validation times out after a partial execution?
Distinguish not-started, staged, committed, and uncertain outcomes. Do not sign again with fresh authority. Reconcile against chain state and keep the reservation until the outcome is known.
Q28. Is the architecture compatible with existing wallets?
Sometimes through a protected signer or an on-chain module. Other designs need wallet or contract changes and cannot be retrofitted transparently.
Q29. How do I handle a delegation that is already installed and malicious?
Use the prepared revocation path: an authorization pointing the account back to the zero address, key rotation, and a sweep to a safe wallet, while the circuit breaker holds other effects.
Q30. What if the simulator shows Arm C winning every scenario?
That follows from how the arms are defined. It tests that the designed logic works as specified. Real evidence needs the real-chain experiments in the evaluation method, with a strengthened Arm B.
Q31. What is the strongest falsification test?
Demonstrate a protected high-value transfer through an unmediated route, or a budget breach under concurrent requests.

B.5. Patents and references

Q32. What should patent examiners or reviewers look for?
Concrete technical distinctions: operation reconstruction, independent authority, mandatory enforcement, state binding, replay prevention, and measurable effects, evaluated against prior art.
Q33. Is this proof of novelty or patentability?
No. Prior-art analysis and claim-specific inventive-step assessment remain necessary.
Q34. How should readers treat the patent and industry references?
They identify the inventor-reported technical provenance. They do not establish implementation, endorsement, adoption, validity, or infringement by any organization. Readers should consult authoritative WIPO and patent-office records and verify all claims before reliance.

Appendix C. Basis of Disclosure and Patent Notice

This document is based on the Mothership application PCT/IB2026/055615, filed 4 June 2026 and published as WO 2026/150382 A2 on 16 July 2026. The full filing can be read by searching "Sangam Das" on WIPO PATENTSCOPE, by searching PCT/IB2026/055615 (pctib202655615), or at https://www.tdcommons.org/dpubs_series/12542/ . The underlying invention is human-originated. Preparation of this draft, its summaries, and any mapping to third-party systems or incidents used AI assistance and may contain errors or omissions, so readers MUST verify against the original filings and primary sources. Nothing here implies endorsement, collaboration, licensing, or an allegation of infringement by any third party. The author is open to acquihire or strategic collaboration.

License: CC BY-NC 4.0. The license does not grant patent rights.

Acknowledgements

The author thanks the security researchers and journalists whose public reporting made the incident discussion possible.

Author's Address

Sangam Kumar Das
Independent
Balasore
Odisha
India