On the EVM there is one attacker axis: msg.sender. Whoever sends the transaction is the actor, and everything on chain is public - so being able to see something and being able to act on it are the same privilege. If you can read the state, you can use it.

Canton breaks that single privilege into two independent ones, and this is the whole game. Every transaction you submit names two sets of parties:

  • actAs - your authority. The right to act: to trigger a contract's actions and put a party on the hook for its obligations.
  • readAs - your disclosure. The right to see: to read a contract's contents.

They don't imply each other. A party can see everything about a contract and have zero power over it. A party can have the power to act inside a transaction whose full contents are hidden from them. Privacy and authorization are separate concerns, so the attacker model is no longer one-dimensional.

Can see it (readAs)
Can't see it
Can act (actAs)
Full powerSees the contract and can exercise it. The only attacker the EVM has, and what you get by testing “as the owner”.
Acting blindHas authority inside a transaction whose contents are hidden. Can they even discover the contract to target it?
Can't act
Seeing, no powerReads everything, can exercise nothing. Still a finding if they were never meant to see it.
OutsiderNo authority, no disclosure. Not even aware the contract exists.

On the EVM only the top-left box exists. On Canton the highlighted boxes are where the attacker usually lives.

EVMCanton
Attacker axesOne: msg.senderTwo: actAs and readAs
Seeing vs actingSame privilege: all state is publicIndependent: neither implies the other
Key questionCan the attacker call this?Can they call it, can they discover it, and what may they reason over?
Common test mistake—Submitting as the victim, which grants both axes and inflates findings

The faithful attacker

The classic mistake is auditing "as the owner" - writing the test as if the attacker submits with the victim's identity. That hands the attacker the victim's authority and the victim's visibility, and every finding inflates. The faithful attacker uses only their own authority and only the disclosure they could actually get.

This matters because many Daml vulnerabilities aren't "crypto bugs" at all. They're authorization mistakes, visibility assumptions, broken business workflows, or invariants that hold for one execution path but not another. The question isn't just "can the attacker call this choice?" but also "can they even discover this contract?" and "what information are they actually allowed to reason over?"


On the EVM, seeing and acting are the same power, so there's one attacker to model. On Canton they're two separate powers, and the attacker rarely holds both. Audit the two axes separately - who can act, and who can see - or you'll inflate half your findings and miss the other half.

Secure your codebase - valvessecurity.com