WritingMarch 2026
Construction Is Not Authorization
The ability to describe a financial action should not automatically confer the ability to authorize it.
A payments backend needs to put gas on a deposit address so a sweep can proceed.
It can assemble the transfer: recipient, amount, chain, empty calldata. Construction is ordinary work for a money-moving system. Without it, nothing useful happens.
The harder question is whether the layer that builds that transaction should also be able to make it irreversible.
In Xpend B2B, we treated that as a capability problem, not a packaging preference. Building payment flows forced a sharper split than “who has access to the wallet?”
Construction Is Not Authority
An unsigned transaction is a description.
It says what should happen if someone later authorizes it. A system that settles crypto for merchants has to produce those descriptions constantly: fund a deposit wallet, approve a spender, sweep a vault, move funds to a merchant destination. The application layer owns the business context for those choices.
Description is not the same as authority.
If the same process that determines the recipient can also apply the key that pays them, then a bug, a bad dependency, or a compromised construction path does not merely propose a wrong payment. It can authorize one.
So we separated the capabilities. The merchant backend constructs unsigned work and declares what it believes the operation is: the intent, the expected destination, the constraints that should hold. It does not hold the private keys that would make those choices final.
The ability to describe a financial action should not automatically confer the ability to authorize it.
Put the Boundary Where Authority Becomes Irreversible
Signing is where a proposed action becomes cryptographically usable on a network. It is the point where authorization is committed, even though the network has not confirmed anything yet.
A signing boundary that behaves like “here are bytes, sign them” is only a remote key. It moves the secret without moving the judgment.
We needed the opposite: independent validation immediately before the key is used.
The signing path receives the unsigned transaction together with a declared intent and a set of constraints. Before signing, it checks whether the request is coherent. Broadly: is this an allowed kind of operation; is it bound to the right chain; does the transaction shape match what that operation is allowed to look like; do the targets match what the caller claimed; do wallet type and intent belong together; where integrity binding applies, does the payload still match what was declared.
Unsupported or incoherent requests fail closed. They are rejected before signing.
The application can still be wrong. The point of the boundary is that being wrong at construction time should not silently become a signature.
When Construction Points the Wrong Way
Consider a gas top-up.
The business intent is narrow: fund a specific deposit address so later sweep work can pay fees. The constructed transaction should send value to that address and do nothing else interesting with calldata.
Now suppose the unsigned transaction actually points somewhere else, while the request still claims the expected destination.
If signing were blind, the mismatch would not matter. The key would authorize whatever destination was encoded.
With an authorization boundary, the mismatch is decisive. The declared constraint and the transaction disagree. Signing refuses. The key is never used for that request.
No drama is required. Construction can be wrong without signing having to become wrong.
Repository history shows this as an intentional evolution: signing moved off local mnemonic handling in the payment path, and policy validation was introduced at the signing boundary. That is an architectural decision about authority, not a story about a breach.
A Signature Is Not a Settlement
There is a second collapse that is easy to make.
Once a transaction is signed, it is tempting to treat the work as done. The dangerous next step is to submit again because confirmation is slow or the broadcast response is unclear.
A signature proves that a constrained action was authorized. It does not prove that the network accepted it, included it, or finalized it.
In our execution path, broadcast is a separate responsibility from signing. Submission can succeed clearly, fail clearly, or land in uncertainty. Uncertainty is not permission to invent a second submission. Blind retry after an ambiguous send can turn one authorized transfer into two movements.
So the system has to keep those states mentally separate: prepared, signed, submitted, confirmed, uncertain. When the outcome is unclear, the safe move is to reconcile with what the network actually shows before constructing and authorizing another attempt.
Signing and execution fail differently. Collapsing them produces a different class of bug than collapsing construction and signing.
Three Capabilities, Three Failure Modes
Construct can describe a financial action. It fails by proposing the wrong thing, or by proposing too freely.
Sign can authorize a constrained financial action. It fails by authorizing the wrong thing, or by authorizing when it should refuse.
Execute can submit that authorization to an external network. It fails by never landing, by landing unseen, or by being retried as if it never happened.
These are different capabilities because each transition introduces a different risk. Construction without keys limits how far a flawed proposal can go. Policy before signing limits what a key will underwrite. Execution that respects uncertainty limits how often one authorization becomes two movements.
When we first approached wallet access in a payments stack, the coarse question was natural: who can touch the key? Building the sweep and settlement paths made a better question unavoidable.
Who can propose an action? Who can authorize it? Who can submit it?
In a money system, those should not be the same capability by default.