(ERC Draft), Secure Transaction Verification and Authorization (STVA) – Stopping Blind Signing & Multisig UI Attacks

Hi everyone,

Following the wave of high-value signing-flow and supply-chain attacks (most notably the 2025 Bybit Safe incident and numerous access-control losses), I am proposing a new ERC focused on making transaction signing independently verifiable and human-meaningful.

Core idea:

Standardize a Verification Payload + independent simulation interface + scoped capabilities so that “what you see is what you sign” becomes enforceable rather than aspirational.

Motivation:

Analysis of major incidents (including the February 2025 Bybit ~$1.4–1.5B Safe multisig compromise and numerous other access-control / signing-flow losses) shows that the majority of high-value thefts no longer rely solely on classic smart-contract bugs. Instead they exploit:

Blind or semi-blind signing of opaque calldata.

Compromised frontends / supply-chain attacks that show a benign UI while presenting malicious calldata for signature.

Lack of independent, machine-checkable simulation before signature.

Overly broad and long-lived approvals / authorizations.

Weak ceremony requirements for multisigs and high-value smart accounts.

Existing standards (EIP-712, ERC-1271, EIP-4337, EIP-7702, ERC-7683 intents, etc.) provide excellent building blocks but do not mandate or standardize the full secure verification loop that signers and verifiers need. This ERC fills that gap at the application layer.

Core Concepts:

Verification Payload, A structured object containing the raw transaction/UserOperation + mandatory metadata.

Semantic Intent, Human- and machine-readable description of the effect (e.g. Transfer 1000

USDC to 0xabc, Upgrade Safe implementation to 0xdef, Install module X with permissions Y

Independent Simulator, Any party (wallet, hardware device, third-party verifier, another signer) that can re-simulate the exact payload and produce a canonical result.

Scoped Capability A short-lived, purpose-limited authorization token (EIP-712 typed data or ERC-1271-compatible) that grants only specific actions.

Key questions:

1. Is the VerificationPayload structure the right shape, or should we lean more heavily on existing intent standards (ERC-7683 etc.)?

2. How strict should the multisig ceremony requirements be for “STVA-compliant” status?

3. Should we define explicit compliance levels (Basic / Standard / Strict)?

4. Best way to integrate with EIP-7702 authorizations and modular accounts (ERC-7579/6900)?

5. Any existing work this overlaps with that I should reference or merge with?

Looking forward to feedback and especially input from wallet teams (Safe, Ambire, MetaMask, Rabby, hardware vendors), custody providers, and security researchers.

1 Like

Hi Oba, good thing to standardize. Bybit showed how little the signers actually saw.

A few thoughts on your questions:

  1. Overlap: ERC-7730 (the clear signing descriptor format Ledger pushed) already defines how a wallet turns calldata and EIP-712 messages into readable fields. ERC-7683 is about cross-chain intent settlement, so I’d reference it rather than build on it. Where STVA could add the most is the part 7730 doesn’t cover: binding what’s displayed to the exact hash being signed.

  2. In Bybit the signers approved a Safe transaction whose operation was a delegatecall to a contract that swapped the Safe’s implementation. If the VerificationPayload made operation type, target and the resulting safeTxHash mandatory fields the device shows, and even the Basic level rejected a delegatecall to a target outside an allowlist, that transaction would have been flagged.

  3. Independence is the hard part. The compromised UI built both the transaction and what the signers were shown, so a simulation served by that same front end proves nothing. I’d require the hash to be recomputed from the raw fields on something the UI doesn’t control (the hardware device, or a second machine running something like safe-tx-hashes-util), and say it explicitly in the spec.

Do you have the payload struct written up somewhere? Much easier to comment on the shape with the fields in front of us.

1 Like

Speaking from the wallet support side rather than engineering: a summary only helps if people actually read it. Short plain-language summaries, with risky actions like unlimited approvals or handing control of an account to a new contract clearly set apart, seem more useful than warning on everything, which people learn to click past. Would STVA define which actions count as high-risk?

Hi Zealynx,

Thank you for the thoughtful and detailed feedback this is exactly the kind of input I was hoping for.

You’re right about the overlap with ERC-7730 Clear signing descriptors already do excellent work turning calldata and EIP-712 messages into human-readable fields. STVA is not trying to replace that. The main addition I’m aiming for is stronger binding between what is displayed to the signer and the exact hash that is ultimately signed, plus clearer requirements around independent verification (especially for multisigs and high-value operations).

On the Bybit example: yes — making operation type to target, and the resulting safeTxHash (or equivalent) mandatory fields that the device/hardware must show, combined with a Basic-level rule that flags or rejects unexpected delegatecall to non-allowlisted targets, would have significantly raised the chance of detection. That’s one of the concrete outcomes I want the standard to enable.

Regarding independence: I completely agree this is the hardest and most important part. A simulation served by the same compromised frontend is worthless. The draft will explicitly require that the final hash is recomputed from the raw fields on a component the primary UI does not control (hardware wallet, second device, or offline tool such as `safe-tx-hashes-util`). I’ll make this a normative requirement for the higher compliance levels.

Here’s the current shape of the VerificationPayload (still open to feedback):

struct VerificationPayload {
bytes32 txHash; // canonical transaction / UserOperation / SafeTxHash
address account; // the account that will execute (Safe, SCA)
address target; // primary target of the call
uint256 value;
bytes callData;
uint8 operation; // 0 = Call, 1 = DelegateCall (for Safe-style)
uint256 chainId;
uint256 nonce;
string semanticIntent; // short human-readable summary
bytes32 intentHash; // hash of structured intent fields
SimulationResult expectedResult; // optional but recommended
Capability[] capabilities; // scoped capabilities being used (if any)
bytes metadata; // additional structured data
}

Thanks for posting it, much easier with the fields in front of us.

For a Safe, the device can’t rebuild txHash from this struct. SafeTx also hashes safeTxGas, baseGas, gasPrice, gasToken and refundReceiver, and the domain uses the Safe as verifyingContract. Those fields matter on their own. With gasPrice above 0 and an ERC-20 gasToken, execTransaction sends (gasUsed + baseGas) * gasPrice of that token to refundReceiver, and nothing caps it except the Safe’s balance. So a transaction with a clean target, value and calldata can still pay out nearly all of the Safe’s balance of that token through the refund. I’d have the payload carry the full preimage for each hash type (SafeTx, a UserOperation plus its EntryPoint, a plain tx) and make the device rebuild txHash and reject on a mismatch.

semanticIntent, expectedResult and metadata come from whoever builds the payload, and in Bybit that was the compromised UI. So I’d treat them as claims the device checks rather than text it displays. At the Strict level the device could derive the summary from callData itself (ERC-7730 descriptors fit here) and flag any difference from semanticIntent.

Thank you — this is excellent and very concrete feedback.

You’re completely right about the Safe case. The current VerificationPayload is missing critical fields that go into the SafeTx hash (safeTxGas, baseGas, gasPrice, gasToken, refundReceiver) as well as the correct domain separator (verifyingContract = the Safe itself). As you pointed out, a transaction can look clean on target / value / calldata and still drain significant value through the gas refund mechanism. That is a real risk the standard must address.

I agree with your recommendation:

The payload should carry the full preimage required to recompute the relevant hash (SafeTx, UserOperation + EntryPoint, or plain transaction), so that the verifying device / hardware can independently rebuild txHash and reject on any mismatch.

semanticIntent expectedResult and metadata should be treated as claims made by the party constructing the payload, not as trusted display text. At the Strict compliance level, the device should preferably derive its own human-readable summary (leveraging ERC-7730 descriptors where available) from the actual callData / preimage and flag any meaningful divergence from the provided semanticIntent

I’ll revise the struct and the verification requirements accordingly in the next version of the draft. The goal is that a compliant hardware wallet or offline verifier can fully reconstruct and validate the hash without trusting the frontend.

Your input on the Safe-specific fields and the claim-vs-derived summary distinction has already improved the design significantly.

Thanks again for the precise and constructive comments.

I have set up a public draft repository for the Secure Transaction Verification and Authorization (STVA) proposal and configured basic CI (Markdown linting, link checking, and codespell).

All checks are currently passing.

Repo:

The current VerificationPayload struct and related notes are in the repo. I’ll keep updating it based on the feedback received so far (especially the SafeTx preimage and claim-vs-derived summary points raised by Zealynx).

I’d really appreciate any further comments on:

• The payload structure

• Compliance levels

• High-risk action classification

• Integration with ERC-7730 / Safe / EIP-7702

Thanks in advance for the continued input.

How does STVA handle a transaction whose hash stays unchanged but whose effects change after simulation?

Suppose a multisig signs a call to a proxy after an independent simulation. The proxy implementation changes before execution. The signature still matches the exact transaction but the simulated outcome no longer describes what will happen.

Does STVA require execution-time checks on the relevant state or expected effects? If not then should compliance explicitly distinguish verified signing data from verified execution outcomes?

1 Like

Thanks for raising this it gets to the core distinction the draft should make explicit.

STVA is about signed authorization intent, not guaranteed execution outcome.

A signature can be valid and still describe a transaction whose actual effect changes if the chain state, proxy implementation, or other conditions change before execution. That is normal in Ethereum and is especially relevant for proxies, upgradeable contracts, and dynamic calldata flows.

So the right model is:

Signing-time verification: What exact intent did the signer authorize?

Simulation-time assessment: What did the transaction appear to do under a specific state snapshot?

Execution-time verification: What did it actually do when executed?

These are related, but they are not the same thing.

STVA should not imply that signed data guarantees final execution semantics. It should instead ensure the signer can review and authorize a clear, structured intent before signing. If the intent is ambiguous, opaque, or high-risk, the wallet or multisig UI should surface that clearly.

This is especially important for proxy calls and upgradeable systems: a transaction’s byte payload may remain the same while the underlying implementation behind the proxy changes. In that case, earlier simulation may no longer match the real execution behavior. That does not invalidate the signature, it means the final effect must be treated as a separate verification problem.

So yes compliance should explicitly distinguish:

verified signing intent,

simulated execution assumptions.

actual execution outcome.

Otherwise, the standard risks creating a false impression that a valid signature equals a verified execution plan.

1 Like

Could this distinction become a normative requirement for compliant wallets? A simulation result should identify the block hash it was evaluated against. Any expected effects that are not enforced at execution should be explicitly labelled as assumptions. Otherwise a generic “verified” badge could still imply the guarantee you have ruled out here.

1 Like

Yes, I think this distinction should become a normative requirement for compliant wallets.

A simulation result is only meaningful relative to a specific execution context.

For that reason, any wallet or tooling that presents a simulation outcome should identify the exact block hash (or other execution checkpoint) it was evaluated against.

Without this, the result is ambiguous and can be misinterpreted as a statement about the transaction’s actual execution state when it may only represent a snapshot of a prior or hypothetical state.

Equally important is the distinction between enforced effects and assumed effects.

If an expected effect is not actually enforced at execution time, it should be explicitly labelled as an assumption rather than as a verified outcome. Otherwise, a generic verified badge may create a misleading impression that the wallet has established guarantees that were never actually checked or enforced.

In other words, compliant wallets should make the following explicit:

the precise execution context used for the simulation.

which outcomes were actually enforced during execution.

which effects are only inferred or assumed;

and whether the reported result is specific to a single block/state or more general.

Could you add this as explicit MUST requirements in the draft? A small compliance example using the proxy-upgrade scenario would help show which labels are acceptable and which would incorrectly imply guaranteed execution. That would address my concern.

1 Like

Thanks — yes, I will make these explicit MUST requirements in the next version of the draft.

Compliant wallets (Standard level and above) MUST clearly communicate:

• The precise execution context used for the simulation (including block hash / state root)

• Which outcomes are actually enforced at execution time

• Which effects are only inferred or assumed

• Whether the simulation result is specific to a particular block state

Proxy Upgrade Scenario

Acceptable labelling (Correct):

Verified Signing Intent:

Upgrade the Safe implementation to 0xNewImplementation

Simulated Execution Assumptions (evaluated against block 0xabc):

• The new implementation will be set

• Assumption: The new implementation is not malicious

• Assumption: No additional storage collisions occur

Actual Execution Outcome:

Only the implementation slot change is enforced by this transaction. All safety properties of the new implementation are assumptions.

Incorrect labelling (Should be rejected / warned):

• Verified: Safe upgraded to secure new implementation

• This transaction is verified and safe

This kind of wording incorrectly implies guarantees that were never checked or enforced.

I’ll add both the normative requirements and this (or a similar) example to the Compliance Levels section.

Appreciate you pushing for this level of precision.

I have set up a public draft repository for the Proxy Upgrade Scenario Result for (STVA) proposal and basic CI (Markdown linting, link checking, and codespell).

All checks are currently passing.

MATOBOYCRYPTO65/Draft-post-upgrade-: Proxy Upgrade Scenario