Design the client and ledger of a wallet or peer-to-peer payments app: integer money, idempotency keys, lost responses and an invariant you can check.

Predict first

A response is lost one time in four and the client retries. What differs between a stable and a fresh key?

print("Double: ten payments of 0.10 sum to", (0..<10).reduce(0.0) { a, _ in a + 0.1 }, "== 1.0?", (0..<10).reduce(0.0) { a, _ in a + 0.1 } == 1.0)
struct Rng { var s: UInt64; mutating func next(_ n: Int) -> Int { s = s &* 6364136223846793005 &+ 1442695040888963407; return Int((s >> 33) % UInt64(n)) } }
// the server posts a transfer as two ledger entries (debit, credit) in integer cents; the response can be lost
final class Server {
    var balance = ["alice": 100_000, "bob": 50_000]
    var done: [String: Bool] = [:]; var applied = 0
    func transfer(key: String, from: String, to: String, cents: Int) {
        if done[key] != nil { return }                                    // idempotency: same key, same effect
        guard balance[from]! >= cents else { done[key] = false; return }
        balance[from]! -= cents; balance[to]! += cents; done[key] = true; applied += 1
    }
}
func simulate(stableKey: Bool) -> (intended: Int, applied: Int, total: Int, alice: Int) {
    var rng = Rng(s: 3); let s = Server()
    for i in 0..<300 {
        let cents = 100 + rng.next(400)
        var attempt = 0
        while true {
            let key = stableKey ? "op\(i)" : "op\(i)-try\(attempt)"
            s.transfer(key: key, from: "alice", to: "bob", cents: cents)
            attempt += 1
            let responseLost = rng.next(4) == 0
            if !responseLost || attempt == 4 { break }                     // client retries on timeout
        }
    }
    return (300, s.applied, s.balance.values.reduce(0, +), s.balance["alice"]!)
}
for stable in [true, false] { let r = simulate(stableKey: stable)
    print(stable ? "stable key per operation:" : "fresh key per attempt:   ", "intended", r.intended, "applied", r.applied, "| money in the system", r.total, "| alice", r.alice) }

• Stable key: 300 applied; fresh key per attempt: 330 applied; the total money is 150000 in both
• Both apply 300
• Fresh keys apply 300 and stable keys apply 330