An audit control that the audited party can switch off is not a control

Shipped a Daml module that makes an asset impossible to move without writing a ledger record of the attempt.

One word on your signatory line and an interface instance.

MIT licensed. No dependencies beyond the standard library.

The problem it solves is one I had for six weeks without seeing it.

I was recording what an agent refused: a hash chain, a counter, and an attempt record.

Every one of them was written by the application, which is the party the evidence is about.

An auditor asking, “Can I trust this record?” was being answered with:

“If the application chose to write one.”

The fix is not cryptography.

It is authorization.

A consuming choice in Daml needs the authority of the contract’s signatories.

So put a second party on the asset:

template Wallet
  with holder : Party
       guard : Party
       balance : Decimal
  where
    signatory holder, guard

interface instance Journalled for Wallet where
  view = JournalledView with owner = holder; guardian = guard
  perform = do ... -- your work, untouched

The guard is also a signatory of the journal, so its authority is reachable only from inside a journal entry.

An application trying to move that wallet any other way holds the owner’s authority and nothing else.

The ledger refuses it.

Not discouraged. Refused.

The limit, because you would find it in a minute.

Daml hands a submitter the authority of every party it submits as.

An operator who can submit as the guard reaches the asset directly, and no record is written.

There is a test that performs that bypass and shows the counter never moves.

So it is a control when the guard is operated by someone who is not the actor, and a convention when one person submits as both.

Segregation of duties does the work.

The code makes it enforceable.

156 Daml scripts.

Deleting any authorization check turns a named test red.

None of it has run on DevNet, because I have never had a credential.

So weigh it as a design until it does.

If you want the reasoning for why a self-written chain is not evidence:

Hearsay (arXiv:2609.32495) injected 28 omissions into deployed agent harnesses.

A log outside the harness caught all 28.

A hash chain over the harness’s own record caught none.

The question.

Without contract keys, is there a Daml 3 way to guarantee an asset cannot be acted on except through a particular contract, without depending on a second party being operated by somebody else?

If there is not, then segregation of duties is the floor for every on-ledger control.

And that is worth knowing before you design one.

Not if the operator can submit as all asset signatories: implicit Archive bypasses the journal.

Audit every choice on the asset and its interfaces. Controllers authorize exercises; actors plus the contract’s signatories authorize consequences. A guard signatory alone does not gate owner-controlled choices. Contract keys (LF 2.3+) don’t remove this bypass: exerciseByKey still requires controllers’ authority.

External signing and decentralized parties can distribute authority, but signing, namespace governance and confirming quorums must remain outside the actor’s unilateral control. Confirmation-only hosting doesn’t help if actor-controlled nodes can form that quorum.

These points follow from the documented authorization model.
I haven’t tested your implementation.

You were right on both counts, and I went and tested the rest of your list.

Implicit Archive is gated by the signatory line, so the owner alone fails. The bypass is submitting as both, which succeeds with the counter at zero: testSubmittingAsTheGuardianDefeatsIt.

Owner-controlled choices: you were right, and my suite had missed it because
the test wallet carried no choices at all. There is one that does now, and it
moves outside the journal with the guardian correctly on the signatory line:
testAnOwnerControlledChoiceStillBypassesTheJournal. It is a requirement on
implementers in the draft now, credited to you.

Keys I cannot test. The build targets LF 2.1.

Your last two points I cannot test either, with no participant and no credential, and they are the ones I wanted to ask you about.

Point five especially. Is the confirming set visible to a reader anywhere after the fact, so independence can be checked, or is it only ever an operational claim about who runs which node?

Thanks for testing those cases and adding the owner-controlled-choice test. The configured confirming set can be inspected afterwards, but independence needs separate evidence.

PartyToParticipant records participant IDs, hosting permissions and the confirmation threshold. With appropriate node Admin API access, ListPartyToParticipant supports historical snapshots and returns validity intervals. Without that access, you can request a topology export for the relevant synchronizer and time, checking its completeness and provenance.

Canton explicitly separates cryptographic identities from real-world ownership. Different node IDs do not prove independent operators. You still need evidence of who controlled the nodes and relevant keys at that time.

That historical configuration identifies eligible confirmers. It does not show which nodes actually supplied approvals for a particular transaction.

That last line is the one I needed, and it splits the claim in two.

Who is named is on the ledger. The guardian and the auditor are signatories of the journal, so a reader of the contract sees which parties they are with no Admin API access and no topology export.

Who ran their node is not, and that is where this stops. Eligibility is recoverable from PartyToParticipant. Participation in a particular transaction is not recoverable at all, and distinct node IDs are not distinct operators.

So the honest claim is that the specification proves authority was split between named parties, not that those parties were independently operated. Independence stays an off-ledger assertion.

Both halves are a test now rather than a sentence: testTheLedgerNamesThePartiesAndNotTheirOperators. It reads the four parties off the contract, checks the guardian is neither the actor nor the auditor, and then rebuilds the payload naming every field, so the day anyone adds an operator or topology field it stops compiling and the limit has to be rewritten by hand instead of quietly outgrown.

Third time you have made this narrower. Thank you.