Most cashier setups you inherit from a legacy processor reuse a small pool of deposit addresses per customer. It looks efficient. It isn't.
The attribution problem
When two players share an address — or the same player uses one address across two sessions — you can't tell whose money is whose without an off-chain memo, a timing correlation, or a support ticket. Every one of those is a failure mode. Memos get dropped, timing overlaps, and support tickets scale linearly with volume.
Fresh addresses fix this at the protocol level. Each transaction has exactly one destination, and that destination maps to exactly one player and one intent. Attribution is a lookup, not a heuristic.
The race-condition problem
Reused addresses invite race conditions. A player initiates a $500 top-up. Before their transaction confirms, a second player is handed the same address for a $2,000 top-up. Now two transactions land at the same address in the same block. Who gets credited what?
You end up writing reconciliation code that reads the mempool, sorts by nonce, and hopes the operator's node saw the same ordering as the chain. This is where operators lose money — not to fraud, but to their own reconciliation logic under load.
How we mint
Every transaction request generates a new address on demand. The address is derived from a hardened key path scoped to the operator, indexed by an internal counter that is monotonically increasing across the operator's entire history. The private key never leaves the vault; the derivation is deterministic.
op_id: 4021
customer_id: 887a
intent: topup
amount: 500 USDT
> derive: m/44'/60'/4021'/0/188422
> address: 0x9c…d3f4The address is watched for exactly one incoming transaction. Once the transaction confirms — or expires after the intent window — the address is retired. It's never reused, never handed out again, never watched again.
What this buys you
- Zero attribution ambiguity. Every inbound has exactly one owner.
- No mempool reconciliation code. The chain is the source of truth.
- Support ticket volume drops. Players don't wonder if their transaction was credited to someone else.
- Cleaner audit trail. On-chain history matches your internal ledger without a translation layer.
The trade-off is address inflation on the wallet side — more addresses to derive, more index storage. Both of those are cheap. Wrong money going to the wrong player is not.