Designing a stablecoin checkout that does not break order state

When teams add USDT or other stablecoin payments to a store, the first implementation usually looks simple: show a wallet address, wait for a transaction, then mark the order as paid.

That works for a demo. It breaks down in production.

The hard part is not generating a payment request. The hard part is keeping order state honest when real customers behave like real customers:

• they choose the wrong network
• they send a partial amount
• they pay after the order expires
• they send two transactions instead of one
• they close the checkout page and come back later
• your webhook is delayed or retried
• your store needs a clean answer: pending, paid, expired, underpaid, or overpaid

A practical stablecoin checkout needs a small state machine, not just a QR code.

The pattern I prefer

For each checkout session, create one payment intent with:

• the requested amount and settlement currency
• the chain/network expected for the transfer
• the receiving address
• an expiry timestamp
• the merchant order reference
• a server-side status field

Then treat blockchain detection as an input to the state machine, not as the state machine itself.

For example:

1. The customer opens checkout and the order is pending.
2. A matching transaction arrives before expiry and the order becomes paid.
3. A smaller matching transaction arrives and the order becomes underpaid.
4. A transaction arrives after expiry and the order needs manual review or refund handling.
5. The webhook retries the same transaction and the system ignores the duplicate.

That last point matters. Payment systems should be idempotent by default. A retry should never create a second successful order.

Where merchants usually get stuck

Most small merchants and SaaS founders do not want to run chain monitors, maintain wallet address logic, write webhook retry handling, or explain network mismatches to customers. They want a checkout link and a clean payment result.

That is the gap I am trying to solve with ChainPay.

ChainPay is a lightweight stablecoin checkout for stores, SaaS products, WooCommerce sites, Telegram businesses, and AI agents. The goal is simple: let a merchant accept USDT payments without building payment infrastructure from scratch.

Current focus:

• simple checkout links
• USDT payment collection
• merchant dashboard
• WooCommerce use cases
• API-friendly checkout for AI agents and SaaS apps

I am currently collecting early feedback before launch.

Product Hunt pre-launch page:
https://www.producthunt.com/products/chainpay?launch=chainpay

Website:
https://chainpay.to/

If you have built crypto checkout, stablecoin billing, WooCommerce payments, or agent payments, I would be interested in what failure cases you think every checkout should handle from day one.