Flair BuchiMiracle Okonkwo

WritingMarch 2026

Exact, Tolerant, and Open: Why Crypto Payment Amounts Need a Policy

The chain answers how much money showed up. The payment system still has to decide what the merchant meant to accept.


A merchant creates a payment for $100.

A payer sends $99.99.

Is it paid?

The chain can tell you that $99.99 arrived. It cannot tell you whether that is enough.

What about $100.01? What about $40? What about a tip jar where $5 is a perfectly good outcome?

Building crypto checkout for merchants at Xpend B2B kept returning us to that gap. The chain answers how much money showed up. The payment system still has to decide what the merchant meant to accept.

The amount a payment system accepts is a policy, not a number.

The Chain Doesn't Know What “Paid” Means

On-chain confirmation is useful. It tells you funds were observed and established for a deposit.

It does not tell you whether the payment intent is funded in the business sense.

A merchant issuing a fixed invoice may treat anything below the target as unfinished. Another merchant may allow a small band around the target. A third merchant may be collecting an open amount, where the meaningful question is closer to “did valid money arrive?” than “did the payer hit $100?”

If the system collapses those cases into one comparison against a single number, it will eventually lie to someone: the merchant, the payer, or both.

So we had to make acceptance explicit.

An Amount Is Not a Policy

$100 alone is incomplete information.

The system also needs to know how to evaluate inbound money against that figure. In our payment intents, that decision is represented as a funding acceptance mode:

  • exact, for fixed invoices
  • target with tolerance, for an amount with an allowed band
  • open amount, for donations, tips, and other variable collections

Those modes are not naming conventions for the UI. They are merchant-facing payment semantics. They are documented for integrators. They are set on the payment intent when it is created, and a funding-policy snapshot is persisted with it so later funding checks evaluate against a known rule instead of inventing one mid-pipeline.

Without that, every settlement path starts inventing its own definition of “enough.”

Exact Doesn't Always Mean Mathematically Exact

Even “exact” needs an explicit rule.

An acceptance mode that assumes perfect mathematical equality everywhere can reject payments that fall within the intended acceptance range.

So exactness, in the product sense, is still a policy. The system deliberately models exact acceptance — including a small absolute band by default — rather than relying on naive literal equality.

The particular width of that band is less important than the fact that exactness is defined up front, stored with the payment intent, and evaluated the same way everywhere the system asks whether funding is satisfied.

Underpayment and Overpayment Are Different Decisions

Too little and too much are not the same failure.

Too little is a shortfall. The payer has not yet satisfied the accepted range. Routing and completion should wait. If the intent allows partial funding, another confirmed deposit may help close the gap. If it does not, the payment remains underfunded until inbound satisfies the policy in the way that policy requires.

Too much is excess. That can be a different decision entirely. The merchant may want excess rejected, or may allow excess to be credited subject to the rules attached to the intent.

Our domain treats those outcomes separately. Funding evaluation can fail because of shortfall or because of excess. Overpayment handling is itself part of the policy: reject the excess, or credit it under the configured rules.

A single boolean called funded hides the difference between “send the rest” and “this payment violated the upper bound.” Progression state, repair guidance, and merchant-facing acceptance all need that distinction.

A Payment Can Arrive in Pieces

A payment intent should not always judge itself by the latest deposit alone.

Someone can send $40, then $60. Whether that counts depends on the intent’s acceptance policy — including whether partial funding is allowed — and on whether cumulative confirmed inbound eventually satisfies the thresholds.

So funding evaluation looks at cumulative confirmed inbound for the payment intent, according to that configured policy. Before the payment progresses toward routing and settlement, a funding gate asks whether that cumulative amount is acceptable.

One confirmed deposit can be true and still leave the intent underfunded. Another deposit can leave it overfunded. The gate exists so settlement does not proceed on a local reading of the last transaction while the payment, as a whole, is still outside policy.

Open Amount Changes the Question

Open-amount collections are not loose invoices.

An invoice asks whether the payer satisfied an agreed amount, possibly within tolerance. An open collection asks whether valid inbound funding arrived under a much simpler rule: there is no fixed commercial target to hit in the same way, and the policy accepts inbound once it clears the open-amount minimum rather than matching a quoted invoice total.

That is why the acceptance mode belongs on the payment intent. The same deposit machinery can observe funds for both cases. The meaning of those funds changes with the mode.

If open amount is implemented as “invoice with a tiny target and lots of special cases,” the special cases will leak forever. If it is a first-class mode, the rest of the system can ask the right question without pretending every payment is a $100 bill that happened to allow variance.

Put the Policy in the Domain

Without a first-class funding policy, acceptance rules tend to leak into webhook handlers, settlement code, reconciliation scripts, checkout UI, and merchant-specific exceptions. Each place invents a slightly different version of “paid.”

We put the policy in the domain instead.

Thresholds are computed from the mode and related settings when the intent is created. The funding-policy snapshot is stored on the intent. Later, when confirmed inbound is evaluated for progression, the funding gate runs the cumulative evaluation against that policy before the payment moves toward routing.

There are still lifecycle edges. An expired invoice, for example, can interact with shortfall handling in a deliberate way. Lifecycle rules should meet an explicit policy, not redefine “funded” inside every branch.

With the acceptance rule in one place, the rest of the system has something consistent to evaluate. Progression can report shortfall or excess honestly. Repair guidance can tell an operator what not to force. Merchant documentation can describe the same semantics the code evaluates.

The Hard Part Was Deciding What “Paid” Means

Comparing two numbers is easy.

Deciding what the comparison means is not.

Merchants do not all mean the same thing by a funded payment. Exact invoices, tolerant targets, and open collections are different products wearing similar deposit machinery. Underpayment and overpayment are different decisions. Multiple deposits may or may not compose into one funded intent, depending on the policy attached to the intent.

A payment system does not just observe money arriving. It has to decide what that money means.

When that decision is explicit, every part of the payment lifecycle has a rule it can evaluate. When it is implicit, every confirmed deposit becomes an argument waiting to happen.