Verifier hardening audit

--- starter/app\contracts.py
+++ reference/app\contracts.py
@@ -1,5 +1,7 @@
 """Request and response construction shared by the HTTP adapter."""
 from dataclasses import dataclass
+import hashlib
+import json
 
 from fastapi.responses import JSONResponse
 
@@ -33,6 +35,10 @@
         return dict(amount_minor=self.amount_minor, currency=self.currency,
                     source_token=self.source_token)
 
+    def fingerprint(self):
+        canonical = json.dumps(self.as_dict(), sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(canonical.encode()).hexdigest()
+
 
 def error(status, code, message=None):
     return JSONResponse({"error": {"code": code, "message": message or code}}, status_code=status)
@@ -41,6 +47,8 @@
 def headers(merchant, key):
     if not merchant:
         return error(400, "merchant_required")
+    if key is None or not 1 <= len(key) <= 255:
+        return error(400, "idempotency_key_required")
     return None
 
 
--- starter/app\main.py
+++ reference/app\main.py
@@ -1,16 +1,22 @@
+import json
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
+from starlette.concurrency import run_in_threadpool
 from app.contracts import PaymentRequest, error, headers
 from app.storage import PaymentStore
 
 
 def create_app(database_url, gateway):
     store = PaymentStore(database_url)
+    with store.connect() as conn:
+        conn.execute("""CREATE TABLE IF NOT EXISTS idempotency_keys (
+            merchant text, key text, fingerprint text NOT NULL, state text NOT NULL,
+            response_code integer, response_json jsonb, PRIMARY KEY(merchant,key))""")
     app = FastAPI()
+
     @app.post("/v1/payments")
     async def pay(request: Request):
-        merchant = request.headers.get("X-Merchant-Id")
-        key = request.headers.get("Idempotency-Key")
+        merchant, key = request.headers.get("X-Merchant-Id"), request.headers.get("Idempotency-Key")
         invalid = headers(merchant, key)
         if invalid is not None:
             return invalid
@@ -18,12 +24,25 @@
             body = PaymentRequest.parse(await request.json())
         except (ValueError, TypeError):
             return error(422, "invalid_payment")
-        return await __import__("starlette.concurrency", fromlist=["run_in_threadpool"]).run_in_threadpool(
-            process, merchant, key, body)
+        return await run_in_threadpool(process, merchant, key, body)
 
     def process(merchant, key, body):
-
+        scope = merchant
+        with store.connect() as conn:
+            inserted = conn.execute("""INSERT INTO idempotency_keys VALUES (%s,%s,%s,'in_progress',NULL,NULL)
+                ON CONFLICT DO NOTHING RETURNING key""", (scope, key, body.fingerprint())).fetchone()
+            if not inserted:
+                row = conn.execute("""SELECT fingerprint,state,response_code,response_json
+                    FROM idempotency_keys WHERE merchant=%s AND key=%s""", (scope, key)).fetchone()
+                if row[0] != body.fingerprint():
+                    return error(422, "idempotency_key_reuse")
+                if row[1] != "complete":
+                    return error(409, "idempotency_request_in_progress")
+                return JSONResponse(row[3], status_code=row[2])
         charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
-        status, payload = store.save(merchant, body, charge)
-        return JSONResponse(payload, status_code=status)
+        with store.connect() as conn:
+            code, payload = store.save(merchant, body, charge, conn)
+            conn.execute("""UPDATE idempotency_keys SET state='complete',response_code=%s,response_json=%s
+                WHERE merchant=%s AND key=%s""", (code, json.dumps(payload), scope, key))
+        return JSONResponse(payload, status_code=code)
     return app

--- starter/app\main.py
+++ alt_valid/app\main.py
@@ -1,29 +1,54 @@
+"""Serialize a request identity for the lifetime of its charging transaction."""
+from datetime import datetime, timezone
+import json
+from uuid import uuid4
+import psycopg
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
-from app.contracts import PaymentRequest, error, headers
-from app.storage import PaymentStore
+from starlette.concurrency import run_in_threadpool
+from app.contracts import PaymentRequest, error, headers, receipt
 
 
 def create_app(database_url, gateway):
-    store = PaymentStore(database_url)
-    app = FastAPI()
-    @app.post("/v1/payments")
-    async def pay(request: Request):
-        merchant = request.headers.get("X-Merchant-Id")
-        key = request.headers.get("Idempotency-Key")
-        invalid = headers(merchant, key)
-        if invalid is not None:
-            return invalid
+    with psycopg.connect(database_url) as setup:
+        setup.execute("""CREATE TABLE IF NOT EXISTS payment_receipts (
+            id text PRIMARY KEY, merchant text, request_key text, request_body jsonb,
+            response jsonb, code int, created_at timestamptz,
+            UNIQUE (merchant, request_key))""")
+
+    def serialized_charge(merchant, key, parsed):
+        with psycopg.connect(database_url) as transaction:
+            lock_identity = json.dumps([merchant, key])
+            transaction.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s,0))", (lock_identity,))
+            previous = transaction.execute("""SELECT request_body,response,code FROM payment_receipts
+                WHERE merchant=%s AND request_key=%s""", (merchant, key)).fetchone()
+            if previous is not None:
+                if previous[0] != parsed.as_dict():
+                    return error(422, "idempotency_key_reuse")
+                return JSONResponse(previous[1], status_code=previous[2])
+            result = gateway.charge(merchant, parsed.amount_minor, parsed.currency, parsed.source_token)
+            identifier = str(uuid4())
+            status, response = receipt(identifier, merchant, parsed, result)
+            transaction.execute("INSERT INTO payment_receipts VALUES (%s,%s,%s,%s,%s,%s,%s)",
+                                (identifier, merchant, key, json.dumps(parsed.as_dict()),
+                                 json.dumps(response), status, datetime.now(timezone.utc)))
+            return JSONResponse(response, status_code=status)
+
+    api = FastAPI()
+
+    @api.post("/v1/payments")
+    async def payment_endpoint(request: Request):
+        merchant_id = request.headers.get("X-Merchant-Id")
+        request_key = request.headers.get("Idempotency-Key")
+        invalid_headers = headers(merchant_id, request_key)
+        if invalid_headers is not None:
+            return invalid_headers
+        if request_key is None or not 1 <= len(request_key) <= 255:
+            return error(400, "idempotency_key_required")
         try:
-            body = PaymentRequest.parse(await request.json())
+            parsed = PaymentRequest.parse(await request.json())
         except (ValueError, TypeError):
             return error(422, "invalid_payment")
-        return await __import__("starlette.concurrency", fromlist=["run_in_threadpool"]).run_in_threadpool(
-            process, merchant, key, body)
+        return await run_in_threadpool(serialized_charge, merchant_id, request_key, parsed)
 
-    def process(merchant, key, body):
-
-        charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
-        status, payload = store.save(merchant, body, charge)
-        return JSONResponse(payload, status_code=status)
-    return app
+    return api

--- starter/app\contracts.py
+++ wrong_inmemory_cache/app\contracts.py
@@ -1,5 +1,7 @@
 """Request and response construction shared by the HTTP adapter."""
 from dataclasses import dataclass
+import hashlib
+import json
 
 from fastapi.responses import JSONResponse
 
@@ -33,6 +35,10 @@
         return dict(amount_minor=self.amount_minor, currency=self.currency,
                     source_token=self.source_token)
 
+    def fingerprint(self):
+        canonical = json.dumps(self.as_dict(), sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(canonical.encode()).hexdigest()
+
 
 def error(status, code, message=None):
     return JSONResponse({"error": {"code": code, "message": message or code}}, status_code=status)
@@ -41,6 +47,8 @@
 def headers(merchant, key):
     if not merchant:
         return error(400, "merchant_required")
+    if key is None or not 1 <= len(key) <= 255:
+        return error(400, "idempotency_key_required")
     return None
 
 
--- starter/app\main.py
+++ wrong_inmemory_cache/app\main.py
@@ -1,3 +1,5 @@
+from threading import Lock
+
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from app.contracts import PaymentRequest, error, headers
@@ -6,6 +8,7 @@
 
 def create_app(database_url, gateway):
     store = PaymentStore(database_url)
+    cache, lock = {}, Lock()
     app = FastAPI()
     @app.post("/v1/payments")
     async def pay(request: Request):
@@ -23,7 +26,15 @@
 
     def process(merchant, key, body):
 
-        charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
-        status, payload = store.save(merchant, body, charge)
-        return JSONResponse(payload, status_code=status)
+        with lock:
+            identity = (merchant, key)
+            if identity in cache:
+                fingerprint, status, payload = cache[identity]
+                if fingerprint != body.fingerprint():
+                    return error(422, "idempotency_key_reuse")
+            else:
+                charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
+                status, payload = store.save(merchant, body, charge)
+                cache[identity] = (body.fingerprint(), status, payload)
+            return JSONResponse(payload, status_code=status)
     return app

--- starter/app\contracts.py
+++ wrong_retry_race/app\contracts.py
@@ -1,5 +1,7 @@
 """Request and response construction shared by the HTTP adapter."""
 from dataclasses import dataclass
+import hashlib
+import json
 
 from fastapi.responses import JSONResponse
 
@@ -33,6 +35,10 @@
         return dict(amount_minor=self.amount_minor, currency=self.currency,
                     source_token=self.source_token)
 
+    def fingerprint(self):
+        canonical = json.dumps(self.as_dict(), sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(canonical.encode()).hexdigest()
+
 
 def error(status, code, message=None):
     return JSONResponse({"error": {"code": code, "message": message or code}}, status_code=status)
@@ -41,6 +47,8 @@
 def headers(merchant, key):
     if not merchant:
         return error(400, "merchant_required")
+    if key is None or not 1 <= len(key) <= 255:
+        return error(400, "idempotency_key_required")
     return None
 
 
--- starter/app\main.py
+++ wrong_retry_race/app\main.py
@@ -1,16 +1,23 @@
+import json
+import psycopg
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
+from starlette.concurrency import run_in_threadpool
 from app.contracts import PaymentRequest, error, headers
 from app.storage import PaymentStore
 
 
 def create_app(database_url, gateway):
     store = PaymentStore(database_url)
+    with store.connect() as conn:
+        conn.execute("""CREATE TABLE IF NOT EXISTS idempotency_keys (
+            merchant text, key text, fingerprint text NOT NULL, state text NOT NULL,
+            response_code integer, response_json jsonb, PRIMARY KEY(merchant,key))""")
     app = FastAPI()
+
     @app.post("/v1/payments")
     async def pay(request: Request):
-        merchant = request.headers.get("X-Merchant-Id")
-        key = request.headers.get("Idempotency-Key")
+        merchant, key = request.headers.get("X-Merchant-Id"), request.headers.get("Idempotency-Key")
         invalid = headers(merchant, key)
         if invalid is not None:
             return invalid
@@ -18,12 +25,25 @@
             body = PaymentRequest.parse(await request.json())
         except (ValueError, TypeError):
             return error(422, "invalid_payment")
-        return await __import__("starlette.concurrency", fromlist=["run_in_threadpool"]).run_in_threadpool(
-            process, merchant, key, body)
+        return await run_in_threadpool(process, merchant, key, body)
 
     def process(merchant, key, body):
-
+        scope = merchant
+        with store.connect() as conn:
+            row = conn.execute("""SELECT fingerprint,state,response_code,response_json
+                FROM idempotency_keys WHERE merchant=%s AND key=%s""", (scope, key)).fetchone()
+            if row:
+                if row[0] != body.fingerprint():
+                    return error(422, "idempotency_key_reuse")
+                return JSONResponse(row[3], status_code=row[2])
         charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
-        status, payload = store.save(merchant, body, charge)
-        return JSONResponse(payload, status_code=status)
+        with store.connect() as conn:
+            code, payload = store.save(merchant, body, charge, conn)
+            try:
+                conn.execute("""INSERT INTO idempotency_keys VALUES (%s,%s,%s,'complete',%s,%s)""",
+                             (scope, key, body.fingerprint(), code, json.dumps(payload)))
+            except psycopg.errors.UniqueViolation:
+                conn.rollback()
+                return error(500, "payment_conflict")
+        return JSONResponse(payload, status_code=code)
     return app

--- starter/app\main.py
+++ wrong_uncached_decline/app\main.py
@@ -1,12 +1,22 @@
+import json
+
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
+from starlette.concurrency import run_in_threadpool
+
 from app.contracts import PaymentRequest, error, headers
 from app.storage import PaymentStore
 
 
 def create_app(database_url, gateway):
     store = PaymentStore(database_url)
+    with store.connect() as conn:
+        conn.execute("""CREATE TABLE IF NOT EXISTS payment_replays (
+            merchant text, key text, request_json jsonb NOT NULL,
+            response_code integer NOT NULL, response_json jsonb NOT NULL,
+            PRIMARY KEY (merchant, key))""")
     app = FastAPI()
+
     @app.post("/v1/payments")
     async def pay(request: Request):
         merchant = request.headers.get("X-Merchant-Id")
@@ -14,16 +24,31 @@
         invalid = headers(merchant, key)
         if invalid is not None:
             return invalid
+        if key is None or not 1 <= len(key) <= 255:
+            return error(400, "idempotency_key_required")
         try:
             body = PaymentRequest.parse(await request.json())
         except (ValueError, TypeError):
             return error(422, "invalid_payment")
-        return await __import__("starlette.concurrency", fromlist=["run_in_threadpool"]).run_in_threadpool(
-            process, merchant, key, body)
+        return await run_in_threadpool(process, merchant, key, body)
 
     def process(merchant, key, body):
+        with store.connect() as conn:
+            conn.execute("SELECT pg_advisory_xact_lock(hashtext(%s), hashtext(%s))",
+                         (merchant, key))
+            previous = conn.execute("""SELECT request_json, response_code, response_json
+                FROM payment_replays WHERE merchant=%s AND key=%s""",
+                                    (merchant, key)).fetchone()
+            if previous:
+                if previous[0] != body.as_dict():
+                    return error(422, "idempotency_key_reuse")
+                return JSONResponse(previous[2], status_code=previous[1])
+            charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
+            status, payload = store.save(merchant, body, charge, conn)
+            # Only completed payments reserve the key; a decline can be attempted again.
+            if charge.status == "succeeded":
+                conn.execute("INSERT INTO payment_replays VALUES (%s,%s,%s,%s,%s)",
+                             (merchant, key, json.dumps(body.as_dict()), status, json.dumps(payload)))
+            return JSONResponse(payload, status_code=status)
 
-        charge = gateway.charge(merchant, body.amount_minor, body.currency, body.source_token)
-        status, payload = store.save(merchant, body, charge)
-        return JSONResponse(payload, status_code=status)
     return app

--- starter/interest\accrual.py
+++ reference/interest\accrual.py
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from datetime import date, timedelta
-from decimal import Decimal
+from decimal import Decimal, localcontext, ROUND_HALF_EVEN
 from interest.calendar import is_month_end, validate
 
 
@@ -13,19 +13,23 @@
 
 def accrue(principal, annual_rate, start, end, method):
     validate(principal, annual_rate, start, end, method)
-    balance, rate, accumulated, days = float(principal), float(annual_rate), 0.0, 0
-    day, result = start, []
-    while day < end:
-        days += 1
-        if method == "daily_compound":
-            accumulated += (balance + accumulated) * rate / 365
-        else:
-            accumulated = balance * rate * days / 365
-        if is_month_end(day):
-            interest = round(accumulated, 2)
-            balance = round(balance + interest, 2)
-            result.append(Posting(day, Decimal(str(interest)).quantize(Decimal("0.01")),
-                                  Decimal(str(balance)).quantize(Decimal("0.01"))))
-            accumulated, days = 0.0, 0
-        day += timedelta(days=1)
-    return result
+    with localcontext() as context:
+        context.prec = 34
+        cent = Decimal("0.01")
+        balance = principal.quantize(cent)
+        accrued = Decimal(0)
+        result = []
+        days = 0
+        day = start
+        while day < end:
+            base = balance + accrued if method == "daily_compound" else balance
+            days += 1
+            accrued = (accrued + base * annual_rate / 365) if method == "daily_compound" else balance * annual_rate * days / 365
+            if is_month_end(day) or day == end - timedelta(days=1):
+                interest = accrued.quantize(cent, rounding=ROUND_HALF_EVEN)
+                balance = (balance + interest).quantize(cent)
+                result.append(Posting(day, interest, balance))
+                accrued = Decimal(0)
+                days = 0
+            day += timedelta(days=1)
+        return result

--- starter/interest\accrual.py
+++ alt_valid/interest\accrual.py
@@ -1,7 +1,8 @@
 from dataclasses import dataclass
-from datetime import date, timedelta
+from datetime import date
 from decimal import Decimal
-from interest.calendar import is_month_end, validate
+from fractions import Fraction
+from interest.calendar import segments, validate
 
 
 @dataclass(frozen=True)
@@ -11,21 +12,29 @@
     balance: Decimal
 
 
+def cents(value):
+    quotient, remainder = divmod(value.numerator * 100, value.denominator)
+    if 2 * remainder > value.denominator or (2 * remainder == value.denominator and quotient % 2):
+        quotient += 1
+    return quotient
+
+
+def money(n):
+    return Decimal(f"{n // 100}.{n % 100:02d}")
+
+
 def accrue(principal, annual_rate, start, end, method):
     validate(principal, annual_rate, start, end, method)
-    balance, rate, accumulated, days = float(principal), float(annual_rate), 0.0, 0
-    day, result = start, []
-    while day < end:
-        days += 1
-        if method == "daily_compound":
-            accumulated += (balance + accumulated) * rate / 365
+    posted_cents = int(principal * 100)
+    factor = Fraction(annual_rate) / 365
+    postings = []
+    for segment in segments(start, end):
+        capital = Fraction(posted_cents, 100)
+        if method == "simple_monthly":
+            earnings = capital * factor * segment.days
         else:
-            accumulated = balance * rate * days / 365
-        if is_month_end(day):
-            interest = round(accumulated, 2)
-            balance = round(balance + interest, 2)
-            result.append(Posting(day, Decimal(str(interest)).quantize(Decimal("0.01")),
-                                  Decimal(str(balance)).quantize(Decimal("0.01"))))
-            accumulated, days = 0.0, 0
-        day += timedelta(days=1)
-    return result
+            earnings = capital * ((1 + factor) ** segment.days - 1)
+        rounded_cents = cents(earnings)
+        posted_cents += rounded_cents
+        postings.append(Posting(segment.last, money(rounded_cents), money(posted_cents)))
+    return postings

--- starter/interest\accrual.py
+++ wrong_actual_actual/interest\accrual.py
@@ -1,7 +1,9 @@
+import calendar
 from dataclasses import dataclass
-from datetime import date, timedelta
-from decimal import Decimal
-from interest.calendar import is_month_end, validate
+from datetime import date
+from decimal import Decimal, ROUND_HALF_EVEN, localcontext
+
+from interest.calendar import segments, validate
 
 
 @dataclass(frozen=True)
@@ -13,19 +15,20 @@
 
 def accrue(principal, annual_rate, start, end, method):
     validate(principal, annual_rate, start, end, method)
-    balance, rate, accumulated, days = float(principal), float(annual_rate), 0.0, 0
-    day, result = start, []
-    while day < end:
-        days += 1
-        if method == "daily_compound":
-            accumulated += (balance + accumulated) * rate / 365
-        else:
-            accumulated = balance * rate * days / 365
-        if is_month_end(day):
-            interest = round(accumulated, 2)
-            balance = round(balance + interest, 2)
-            result.append(Posting(day, Decimal(str(interest)).quantize(Decimal("0.01")),
-                                  Decimal(str(balance)).quantize(Decimal("0.01"))))
-            accumulated, days = 0.0, 0
-        day += timedelta(days=1)
+    result = []
+    with localcontext() as context:
+        context.prec = 34
+        cent = Decimal("0.01")
+        balance = principal.quantize(cent)
+        for segment in segments(start, end):
+            year_days = 366 if calendar.isleap(segment.first.year) else 365
+            if method == "simple_monthly":
+                accumulated = balance * annual_rate * segment.days / year_days
+            else:
+                accumulated = Decimal(0)
+                for _ in range(segment.days):
+                    accumulated += (balance + accumulated) * annual_rate / year_days
+            interest = accumulated.quantize(cent, rounding=ROUND_HALF_EVEN)
+            balance = (balance + interest).quantize(cent)
+            result.append(Posting(segment.last, interest, balance))
     return result

--- starter/interest\accrual.py
+++ wrong_float/interest\accrual.py
@@ -21,7 +21,7 @@
             accumulated += (balance + accumulated) * rate / 365
         else:
             accumulated = balance * rate * days / 365
-        if is_month_end(day):
+        if is_month_end(day) or day == end - timedelta(days=1):
             interest = round(accumulated, 2)
             balance = round(balance + interest, 2)
             result.append(Posting(day, Decimal(str(interest)).quantize(Decimal("0.01")),

--- starter/interest\accrual.py
+++ wrong_half_up/interest\accrual.py
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from datetime import date, timedelta
-from decimal import Decimal
+from decimal import Decimal, localcontext, ROUND_HALF_UP
 from interest.calendar import is_month_end, validate
 
 
@@ -13,19 +13,23 @@
 
 def accrue(principal, annual_rate, start, end, method):
     validate(principal, annual_rate, start, end, method)
-    balance, rate, accumulated, days = float(principal), float(annual_rate), 0.0, 0
-    day, result = start, []
-    while day < end:
-        days += 1
-        if method == "daily_compound":
-            accumulated += (balance + accumulated) * rate / 365
-        else:
-            accumulated = balance * rate * days / 365
-        if is_month_end(day):
-            interest = round(accumulated, 2)
-            balance = round(balance + interest, 2)
-            result.append(Posting(day, Decimal(str(interest)).quantize(Decimal("0.01")),
-                                  Decimal(str(balance)).quantize(Decimal("0.01"))))
-            accumulated, days = 0.0, 0
-        day += timedelta(days=1)
-    return result
+    with localcontext() as context:
+        context.prec = 34
+        cent = Decimal("0.01")
+        balance = principal.quantize(cent)
+        accrued = Decimal(0)
+        result = []
+        days = 0
+        day = start
+        while day < end:
+            base = balance + accrued if method == "daily_compound" else balance
+            days += 1
+            accrued = (accrued + base * annual_rate / 365) if method == "daily_compound" else balance * annual_rate * days / 365
+            if is_month_end(day) or day == end - timedelta(days=1):
+                interest = accrued.quantize(cent, rounding=ROUND_HALF_UP)
+                balance = (balance + interest).quantize(cent)
+                result.append(Posting(day, interest, balance))
+                accrued = Decimal(0)
+                days = 0
+            day += timedelta(days=1)
+        return result

--- starter/fx\quote.py
+++ reference/fx\quote.py
@@ -1,15 +1,22 @@
-from decimal import Decimal, ROUND_HALF_EVEN
-from fx.models import Quote, RateUnavailable, validate
+from decimal import Decimal, ROUND_HALF_EVEN, localcontext
+from fx.models import Quote, RateUnavailable, UNITS, validate
 
 __all__ = ["quote_transfer", "Quote", "RateUnavailable"]
 
 
 def quote_transfer(amount_minor, src, dst, rates, fee_bps):
     validate(amount_minor, src, dst, fee_bps)
-    try:
-        rate = rates[src, dst]
-    except KeyError as exc:
-        raise RateUnavailable((src, dst)) from exc
-    fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    converted = int((Decimal(amount_minor) * rate).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    return Quote(fee, converted, rate, (src, dst))
+    with localcontext() as ctx:
+        ctx.prec = max(50, len(str(amount_minor)) + sum(len(r.as_tuple().digits) for r in rates.values()) + 20)
+        if (src, dst) in rates:
+            rate, path = rates[src, dst], (src, dst)
+        else:
+            try:
+                rate = rates[src, "USD"] * rates["USD", dst]
+            except KeyError as exc:
+                raise RateUnavailable((src, dst)) from exc
+            path = (src, "USD", dst)
+        fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        net = Decimal(amount_minor - fee).scaleb(-UNITS[src])
+        converted = int((net * rate).scaleb(UNITS[dst]).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        return Quote(fee, converted, rate, path)

--- starter/fx\quote.py
+++ alt_valid/fx\quote.py
@@ -1,15 +1,32 @@
-from decimal import Decimal, ROUND_HALF_EVEN
-from fx.models import Quote, RateUnavailable, validate
+from decimal import Decimal, localcontext
+from fractions import Fraction
+from fx.models import Quote, RateUnavailable, UNITS, validate
 
 __all__ = ["quote_transfer", "Quote", "RateUnavailable"]
 
 
+def nearest_even(value):
+    integer, residue = divmod(value.numerator, value.denominator)
+    doubled = residue * 2
+    return integer + int(doubled > value.denominator or (doubled == value.denominator and integer % 2))
+
+
 def quote_transfer(amount_minor, src, dst, rates, fee_bps):
     validate(amount_minor, src, dst, fee_bps)
-    try:
-        rate = rates[src, dst]
-    except KeyError as exc:
-        raise RateUnavailable((src, dst)) from exc
-    fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    converted = int((Decimal(amount_minor) * rate).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    return Quote(fee, converted, rate, (src, dst))
+    route = (src, dst) if (src, dst) in rates else (src, "USD", dst)
+    factors = []
+    for pair in zip(route, route[1:]):
+        if pair not in rates:
+            raise RateUnavailable(pair)
+        factors.append(rates[pair])
+    with localcontext() as arithmetic:
+        arithmetic.prec = max(34, sum(len(f.as_tuple().digits) for f in factors) + 10)
+        decimal_rate = Decimal(1)
+        for factor in factors:
+            decimal_rate *= factor
+    exact_rate = Fraction(1)
+    for factor in factors:
+        exact_rate *= Fraction(factor)
+    commission = nearest_even(Fraction(amount_minor * fee_bps, 10000))
+    destination = Fraction(amount_minor - commission, 10**UNITS[src]) * exact_rate * 10**UNITS[dst]
+    return Quote(commission, nearest_even(destination), decimal_rate, route)

--- starter/fx\quote.py
+++ wrong_fee_after_conversion/fx\quote.py
@@ -1,15 +1,23 @@
-from decimal import Decimal, ROUND_HALF_EVEN
-from fx.models import Quote, RateUnavailable, validate
+from decimal import Decimal, ROUND_HALF_EVEN, localcontext
+from fx.models import Quote, RateUnavailable, UNITS, validate
 
 __all__ = ["quote_transfer", "Quote", "RateUnavailable"]
 
 
 def quote_transfer(amount_minor, src, dst, rates, fee_bps):
     validate(amount_minor, src, dst, fee_bps)
-    try:
-        rate = rates[src, dst]
-    except KeyError as exc:
-        raise RateUnavailable((src, dst)) from exc
-    fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    converted = int((Decimal(amount_minor) * rate).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    return Quote(fee, converted, rate, (src, dst))
+    with localcontext() as ctx:
+        ctx.prec = max(50, len(str(amount_minor)) + sum(len(r.as_tuple().digits) for r in rates.values()) + 20)
+        if (src, dst) in rates:
+            rate, path = rates[src, dst], (src, dst)
+        else:
+            try:
+                rate = rates[src, "USD"] * rates["USD", dst]
+            except KeyError as exc:
+                raise RateUnavailable((src, dst)) from exc
+            path = (src, "USD", dst)
+        fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        net = Decimal(amount_minor).scaleb(-UNITS[src])
+        converted = int((net * rate).scaleb(UNITS[dst]).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        converted -= int((Decimal(converted) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        return Quote(fee, converted, rate, path)

--- starter/fx\quote.py
+++ wrong_round_cross_leg/fx\quote.py
@@ -1,15 +1,27 @@
-from decimal import Decimal, ROUND_HALF_EVEN
-from fx.models import Quote, RateUnavailable, validate
+from decimal import Decimal, ROUND_HALF_EVEN, localcontext
+from fx.models import Quote, RateUnavailable, UNITS, validate
 
 __all__ = ["quote_transfer", "Quote", "RateUnavailable"]
 
 
 def quote_transfer(amount_minor, src, dst, rates, fee_bps):
     validate(amount_minor, src, dst, fee_bps)
-    try:
-        rate = rates[src, dst]
-    except KeyError as exc:
-        raise RateUnavailable((src, dst)) from exc
-    fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    converted = int((Decimal(amount_minor) * rate).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    return Quote(fee, converted, rate, (src, dst))
+    with localcontext() as ctx:
+        ctx.prec = max(50, len(str(amount_minor)) + sum(len(r.as_tuple().digits) for r in rates.values()) + 20)
+        if (src, dst) in rates:
+            rate, path = rates[src, dst], (src, dst)
+        else:
+            try:
+                rate = rates[src, "USD"] * rates["USD", dst]
+            except KeyError as exc:
+                raise RateUnavailable((src, dst)) from exc
+            path = (src, "USD", dst)
+        fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        net = Decimal(amount_minor - fee).scaleb(-UNITS[src])
+        if len(path) == 3:
+            net = (net * rates[src, "USD"]).quantize(Decimal(".01"), rounding=ROUND_HALF_EVEN)
+            rate_for_amount = rates["USD", dst]
+        else:
+            rate_for_amount = rate
+        converted = int((net * rate_for_amount).scaleb(UNITS[dst]).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        return Quote(fee, converted, rate, path)

--- starter/fx\quote.py
+++ wrong_two_decimals/fx\quote.py
@@ -1,4 +1,4 @@
-from decimal import Decimal, ROUND_HALF_EVEN
+from decimal import Decimal, ROUND_HALF_EVEN, localcontext
 from fx.models import Quote, RateUnavailable, validate
 
 __all__ = ["quote_transfer", "Quote", "RateUnavailable"]
@@ -6,10 +6,17 @@
 
 def quote_transfer(amount_minor, src, dst, rates, fee_bps):
     validate(amount_minor, src, dst, fee_bps)
-    try:
-        rate = rates[src, dst]
-    except KeyError as exc:
-        raise RateUnavailable((src, dst)) from exc
-    fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    converted = int((Decimal(amount_minor) * rate).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
-    return Quote(fee, converted, rate, (src, dst))
+    with localcontext() as ctx:
+        ctx.prec = max(50, len(str(amount_minor)) + sum(len(r.as_tuple().digits) for r in rates.values()) + 20)
+        if (src, dst) in rates:
+            rate, path = rates[src, dst], (src, dst)
+        else:
+            try:
+                rate = rates[src, "USD"] * rates["USD", dst]
+            except KeyError as exc:
+                raise RateUnavailable((src, dst)) from exc
+            path = (src, "USD", dst)
+        fee = int((Decimal(amount_minor) * fee_bps / 10000).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        net = Decimal(amount_minor - fee).scaleb(-2)
+        converted = int((net * rate).scaleb(2).quantize(Decimal(1), rounding=ROUND_HALF_EVEN))
+        return Quote(fee, converted, rate, path)

--- starter/recon\engine.py
+++ reference/recon\engine.py
@@ -1,22 +1,60 @@
 """Statement-to-ledger matching."""
 from recon.models import StatementLine, LedgerEntry, Match, ReconResult  # noqa: F401
 
+WINDOW_DAYS = 3
 
-def exact_candidates(line, ledger):
-    """Ledger payments that agree with a statement line on reference, amount and booking date."""
+
+def day_gap(entry, line):
+    return abs((entry.booking_date - line.value_date).days)
+
+
+def exact_candidates(line, ledger, used_ledger):
+    """Unused ledger payments that agree on reference and amount within the date window."""
     return [entry for entry in ledger
-            if entry.kind == "payment" and entry.reference == line.reference
-            and entry.amount_minor == line.amount_minor and entry.booking_date == line.value_date]
+            if entry.id not in used_ledger and entry.kind == "payment"
+            and entry.reference == line.reference and entry.amount_minor == line.amount_minor
+            and day_gap(entry, line) <= WINDOW_DAYS]
+
+
+def split_group(entry, ordered, used_statement):
+    """All unused statement lines for the entry's reference inside the window, if they sum to it."""
+    group = [line for line in ordered if line.id not in used_statement
+             and line.reference == entry.reference and day_gap(entry, line) <= WINDOW_DAYS]
+    if len(group) >= 2 and sum(line.amount_minor for line in group) == entry.amount_minor:
+        return group
+    return []
+
+
+def refund_candidates(line, ledger, used_ledger):
+    return [entry for entry in ledger
+            if entry.id not in used_ledger and entry.kind == "refund"
+            and entry.original_reference == line.reference and entry.amount_minor == -line.amount_minor]
 
 
 def reconcile(statement, ledger):
-    matches, matched = [], set()
-    for line in sorted(statement, key=lambda s: (s.value_date, s.id)):
-        candidates = exact_candidates(line, ledger)
+    ordered = sorted(statement, key=lambda s: (s.value_date, s.id))
+    used_statement, used_ledger, matches = set(), set(), []
+
+    def record(lines, entry, rule):
+        used_statement.update(line.id for line in lines)
+        used_ledger.add(entry.id)
+        matches.append(Match(frozenset(line.id for line in lines), frozenset([entry.id]), rule))
+
+    for line in ordered:
+        candidates = exact_candidates(line, ledger, used_ledger)
         if candidates:
-            entry = min(candidates, key=lambda e: e.id)
-            matches.append(Match(frozenset([line.id]), frozenset([entry.id]), "R1"))
-            matched.add(line.id)
-    unmatched = {s.id: "no_match" for s in statement if s.id not in matched}
-    used = {identifier for match in matches for identifier in match.ledger_ids}
-    return ReconResult(matches, unmatched, {e.id for e in ledger} - used)
+            record([line], min(candidates, key=lambda e: (day_gap(e, line), e.booking_date, e.id)), "R1")
+    for entry in sorted(ledger, key=lambda e: (e.reference, e.booking_date, e.id)):
+        if entry.id not in used_ledger and entry.kind == "payment":
+            group = split_group(entry, ordered, used_statement)
+            if group:
+                record(group, entry, "R2")
+    for line in ordered:
+        if line.id not in used_statement and line.amount_minor < 0:
+            candidates = refund_candidates(line, ledger, used_ledger)
+            if candidates:
+                record([line], min(candidates, key=lambda e: (e.booking_date, e.id)), "R3")
+    matched_signatures = {(s.value_date, s.amount_minor, s.reference) for s in statement if s.id in used_statement}
+    unmatched = {line.id: "duplicate" if (line.value_date, line.amount_minor, line.reference) in matched_signatures
+                 else "no_match" for line in ordered if line.id not in used_statement}
+    return ReconResult(matches, unmatched, {e.id for e in ledger} - used_ledger)

--- starter/recon\engine.py
+++ alt_valid/recon\engine.py
@@ -1,22 +1,49 @@
-"""Statement-to-ledger matching."""
+from collections import defaultdict
 from recon.models import StatementLine, LedgerEntry, Match, ReconResult  # noqa: F401
 
 
-def exact_candidates(line, ledger):
-    """Ledger payments that agree with a statement line on reference, amount and booking date."""
-    return [entry for entry in ledger
-            if entry.kind == "payment" and entry.reference == line.reference
-            and entry.amount_minor == line.amount_minor and entry.booking_date == line.value_date]
+def reconcile(statement, ledger):
+    pending = {s.id: s for s in statement}
+    remaining = {e.id: e for e in ledger}
+    by_reference = defaultdict(list)
+    for entry in ledger:
+        if entry.kind == "payment":
+            by_reference[entry.reference].append(entry)
+    output = []
+    consumed_signatures = set()
 
+    def take(ids, target, rule):
+        for identifier in ids:
+            line = pending.pop(identifier)
+            consumed_signatures.add((line.value_date, line.amount_minor, line.reference))
+        del remaining[target]
+        output.append(Match(frozenset(ids), frozenset([target]), rule))
 
-def reconcile(statement, ledger):
-    matches, matched = [], set()
-    for line in sorted(statement, key=lambda s: (s.value_date, s.id)):
-        candidates = exact_candidates(line, ledger)
-        if candidates:
-            entry = min(candidates, key=lambda e: e.id)
-            matches.append(Match(frozenset([line.id]), frozenset([entry.id]), "R1"))
-            matched.add(line.id)
-    unmatched = {s.id: "no_match" for s in statement if s.id not in matched}
-    used = {identifier for match in matches for identifier in match.ledger_ids}
-    return ReconResult(matches, unmatched, {e.id for e in ledger} - used)
+    for line in sorted(statement, key=lambda v: (v.value_date, v.id)):
+        possible = sorted((abs((e.booking_date - line.value_date).days), e.booking_date, e.id)
+                          for e in by_reference[line.reference]
+                          if e.id in remaining and e.amount_minor == line.amount_minor
+                          and abs((e.booking_date - line.value_date).days) <= 3)
+        if possible:
+            take([line.id], possible[0][2], "R1")
+    for target in sorted(ledger, key=lambda v: (v.reference, v.booking_date, v.id)):
+        if target.id not in remaining or target.kind != "payment":
+            continue
+        ids = [i for i, s in pending.items() if s.reference == target.reference
+               and abs((s.value_date - target.booking_date).days) <= 3]
+        total = sum(pending[i].amount_minor for i in ids)
+        if len(ids) > 1 and total == target.amount_minor:
+            take(ids, target.id, "R2")
+    for line in sorted(list(pending.values()), key=lambda v: (v.value_date, v.id)):
+        if line.amount_minor >= 0:
+            continue
+        refunds = sorted((e.booking_date, e.id) for e in remaining.values()
+                         if e.kind == "refund" and e.original_reference == line.reference
+                         and e.amount_minor + line.amount_minor == 0)
+        if refunds:
+            take([line.id], refunds[0][1], "R3")
+    reasons = {}
+    for identifier, line in pending.items():
+        signature = line.value_date, line.amount_minor, line.reference
+        reasons[identifier] = "duplicate" if signature in consumed_signatures else "no_match"
+    return ReconResult(output, reasons, set(remaining))

--- starter/recon\engine.py
+++ wrong_no_consumption/recon\engine.py
@@ -1,22 +1,60 @@
 """Statement-to-ledger matching."""
 from recon.models import StatementLine, LedgerEntry, Match, ReconResult  # noqa: F401
 
+WINDOW_DAYS = 3
+
+
+def day_gap(entry, line):
+    return abs((entry.booking_date - line.value_date).days)
+
 
 def exact_candidates(line, ledger):
-    """Ledger payments that agree with a statement line on reference, amount and booking date."""
+    """Unused ledger payments that agree on reference and amount within the date window."""
     return [entry for entry in ledger
-            if entry.kind == "payment" and entry.reference == line.reference
-            and entry.amount_minor == line.amount_minor and entry.booking_date == line.value_date]
+            if entry.kind == "payment"
+            and entry.reference == line.reference and entry.amount_minor == line.amount_minor
+            and day_gap(entry, line) <= WINDOW_DAYS]
+
+
+def split_group(entry, ordered, used_statement):
+    """All unused statement lines for the entry's reference inside the window, if they sum to it."""
+    group = [line for line in ordered if line.id not in used_statement
+             and line.reference == entry.reference and day_gap(entry, line) <= WINDOW_DAYS]
+    if len(group) >= 2 and sum(line.amount_minor for line in group) == entry.amount_minor:
+        return group
+    return []
+
+
+def refund_candidates(line, ledger, used_ledger):
+    return [entry for entry in ledger
+            if entry.id not in used_ledger and entry.kind == "refund"
+            and entry.original_reference == line.reference and entry.amount_minor == -line.amount_minor]
 
 
 def reconcile(statement, ledger):
-    matches, matched = [], set()
-    for line in sorted(statement, key=lambda s: (s.value_date, s.id)):
+    ordered = sorted(statement, key=lambda s: (s.value_date, s.id))
+    used_statement, used_ledger, matches = set(), set(), []
+
+    def record(lines, entry, rule):
+        used_statement.update(line.id for line in lines)
+        used_ledger.add(entry.id)
+        matches.append(Match(frozenset(line.id for line in lines), frozenset([entry.id]), rule))
+
+    for line in ordered:
         candidates = exact_candidates(line, ledger)
         if candidates:
-            entry = min(candidates, key=lambda e: e.id)
-            matches.append(Match(frozenset([line.id]), frozenset([entry.id]), "R1"))
-            matched.add(line.id)
-    unmatched = {s.id: "no_match" for s in statement if s.id not in matched}
-    used = {identifier for match in matches for identifier in match.ledger_ids}
-    return ReconResult(matches, unmatched, {e.id for e in ledger} - used)
+            record([line], min(candidates, key=lambda e: (day_gap(e, line), e.booking_date, e.id)), "R1")
+    for entry in sorted(ledger, key=lambda e: (e.reference, e.booking_date, e.id)):
+        if entry.id not in used_ledger and entry.kind == "payment":
+            group = split_group(entry, ordered, used_statement)
+            if group:
+                record(group, entry, "R2")
+    for line in ordered:
+        if line.id not in used_statement and line.amount_minor < 0:
+            candidates = refund_candidates(line, ledger, used_ledger)
+            if candidates:
+                record([line], min(candidates, key=lambda e: (e.booking_date, e.id)), "R3")
+    matched_signatures = {(s.value_date, s.amount_minor, s.reference) for s in statement if s.id in used_statement}
+    unmatched = {line.id: "duplicate" if (line.value_date, line.amount_minor, line.reference) in matched_signatures
+                 else "no_match" for line in ordered if line.id not in used_statement}
+    return ReconResult(matches, unmatched, {e.id for e in ledger} - used_ledger)

--- starter/recon\engine.py
+++ wrong_refund_abs/recon\engine.py
@@ -1,22 +1,60 @@
 """Statement-to-ledger matching."""
 from recon.models import StatementLine, LedgerEntry, Match, ReconResult  # noqa: F401
 
+WINDOW_DAYS = 3
 
-def exact_candidates(line, ledger):
-    """Ledger payments that agree with a statement line on reference, amount and booking date."""
+
+def day_gap(entry, line):
+    return abs((entry.booking_date - line.value_date).days)
+
+
+def exact_candidates(line, ledger, used_ledger):
+    """Unused ledger payments that agree on reference and amount within the date window."""
     return [entry for entry in ledger
-            if entry.kind == "payment" and entry.reference == line.reference
-            and entry.amount_minor == line.amount_minor and entry.booking_date == line.value_date]
+            if entry.id not in used_ledger and entry.kind == "payment"
+            and entry.reference == line.reference and entry.amount_minor == abs(line.amount_minor)
+            and day_gap(entry, line) <= WINDOW_DAYS]
+
+
+def split_group(entry, ordered, used_statement):
+    """All unused statement lines for the entry's reference inside the window, if they sum to it."""
+    group = [line for line in ordered if line.id not in used_statement
+             and line.reference == entry.reference and day_gap(entry, line) <= WINDOW_DAYS]
+    if len(group) >= 2 and sum(line.amount_minor for line in group) == entry.amount_minor:
+        return group
+    return []
+
+
+def refund_candidates(line, ledger, used_ledger):
+    return [entry for entry in ledger
+            if entry.id not in used_ledger and entry.kind == "refund"
+            and entry.original_reference == line.reference and entry.amount_minor == -line.amount_minor]
 
 
 def reconcile(statement, ledger):
-    matches, matched = [], set()
-    for line in sorted(statement, key=lambda s: (s.value_date, s.id)):
-        candidates = exact_candidates(line, ledger)
+    ordered = sorted(statement, key=lambda s: (s.value_date, s.id))
+    used_statement, used_ledger, matches = set(), set(), []
+
+    def record(lines, entry, rule):
+        used_statement.update(line.id for line in lines)
+        used_ledger.add(entry.id)
+        matches.append(Match(frozenset(line.id for line in lines), frozenset([entry.id]), rule))
+
+    for line in ordered:
+        candidates = exact_candidates(line, ledger, used_ledger)
         if candidates:
-            entry = min(candidates, key=lambda e: e.id)
-            matches.append(Match(frozenset([line.id]), frozenset([entry.id]), "R1"))
-            matched.add(line.id)
-    unmatched = {s.id: "no_match" for s in statement if s.id not in matched}
-    used = {identifier for match in matches for identifier in match.ledger_ids}
-    return ReconResult(matches, unmatched, {e.id for e in ledger} - used)
+            record([line], min(candidates, key=lambda e: (day_gap(e, line), e.booking_date, e.id)), "R1")
+    for entry in sorted(ledger, key=lambda e: (e.reference, e.booking_date, e.id)):
+        if entry.id not in used_ledger and entry.kind == "payment":
+            group = split_group(entry, ordered, used_statement)
+            if group:
+                record(group, entry, "R2")
+    for line in ordered:
+        if line.id not in used_statement and line.amount_minor < 0:
+            candidates = refund_candidates(line, ledger, used_ledger)
+            if candidates:
+                record([line], min(candidates, key=lambda e: (e.booking_date, e.id)), "R3")
+    matched_signatures = {(s.value_date, s.amount_minor, s.reference) for s in statement if s.id in used_statement}
+    unmatched = {line.id: "duplicate" if (line.value_date, line.amount_minor, line.reference) in matched_signatures
+                 else "no_match" for line in ordered if line.id not in used_statement}
+    return ReconResult(matches, unmatched, {e.id for e in ledger} - used_ledger)

--- starter/recon\engine.py
+++ wrong_split_ignored/recon\engine.py
@@ -1,22 +1,46 @@
 """Statement-to-ledger matching."""
 from recon.models import StatementLine, LedgerEntry, Match, ReconResult  # noqa: F401
 
+WINDOW_DAYS = 3
 
-def exact_candidates(line, ledger):
-    """Ledger payments that agree with a statement line on reference, amount and booking date."""
+
+def day_gap(entry, line):
+    return abs((entry.booking_date - line.value_date).days)
+
+
+def exact_candidates(line, ledger, used_ledger):
+    """Unused ledger payments that agree on reference and amount within the date window."""
     return [entry for entry in ledger
-            if entry.kind == "payment" and entry.reference == line.reference
-            and entry.amount_minor == line.amount_minor and entry.booking_date == line.value_date]
+            if entry.id not in used_ledger and entry.kind == "payment"
+            and entry.reference == line.reference and entry.amount_minor == line.amount_minor
+            and day_gap(entry, line) <= WINDOW_DAYS]
+
+
+def refund_candidates(line, ledger, used_ledger):
+    return [entry for entry in ledger
+            if entry.id not in used_ledger and entry.kind == "refund"
+            and entry.original_reference == line.reference and entry.amount_minor == -line.amount_minor]
 
 
 def reconcile(statement, ledger):
-    matches, matched = [], set()
-    for line in sorted(statement, key=lambda s: (s.value_date, s.id)):
-        candidates = exact_candidates(line, ledger)
+    ordered = sorted(statement, key=lambda s: (s.value_date, s.id))
+    used_statement, used_ledger, matches = set(), set(), []
+
+    def record(lines, entry, rule):
+        used_statement.update(line.id for line in lines)
+        used_ledger.add(entry.id)
+        matches.append(Match(frozenset(line.id for line in lines), frozenset([entry.id]), rule))
+
+    for line in ordered:
+        candidates = exact_candidates(line, ledger, used_ledger)
         if candidates:
-            entry = min(candidates, key=lambda e: e.id)
-            matches.append(Match(frozenset([line.id]), frozenset([entry.id]), "R1"))
-            matched.add(line.id)
-    unmatched = {s.id: "no_match" for s in statement if s.id not in matched}
-    used = {identifier for match in matches for identifier in match.ledger_ids}
-    return ReconResult(matches, unmatched, {e.id for e in ledger} - used)
+            record([line], min(candidates, key=lambda e: (day_gap(e, line), e.booking_date, e.id)), "R1")
+    for line in ordered:
+        if line.id not in used_statement and line.amount_minor < 0:
+            candidates = refund_candidates(line, ledger, used_ledger)
+            if candidates:
+                record([line], min(candidates, key=lambda e: (e.booking_date, e.id)), "R3")
+    matched_signatures = {(s.value_date, s.amount_minor, s.reference) for s in statement if s.id in used_statement}
+    unmatched = {line.id: "duplicate" if (line.value_date, line.amount_minor, line.reference) in matched_signatures
+                 else "no_match" for line in ordered if line.id not in used_statement}
+    return ReconResult(matches, unmatched, {e.id for e in ledger} - used_ledger)

--- starter/ledger\schema.py
+++ reference/ledger\schema.py
@@ -2,7 +2,11 @@
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS accounts(code text PRIMARY KEY, currency text NOT NULL);
-CREATE TABLE IF NOT EXISTS transactions(id bigserial PRIMARY KEY, memo text);
+CREATE TABLE IF NOT EXISTS transactions(
+    id bigserial PRIMARY KEY,
+    memo text,
+    reversal_of bigint REFERENCES transactions(id),
+    reversed_by bigint);
 CREATE TABLE IF NOT EXISTS lines(
     txn bigint REFERENCES transactions(id),
     code text REFERENCES accounts(code),
--- starter/ledger\service.py
+++ reference/ledger\service.py
@@ -1,3 +1,4 @@
+from collections import defaultdict
 import psycopg
 from ledger.models import (Line, LedgerError, UnbalancedTransaction, InvalidAmount, UnknownAccount,
                            AlreadyReversed, CannotReverseReversal, CURRENCIES, validate_lines)  # noqa: F401
@@ -15,7 +16,7 @@
             conn.execute(SCHEMA)
 
     def connect(self):
-        return psycopg.connect(self.url, autocommit=True)
+        return psycopg.connect(self.url)
 
     def create_account(self, code, currency):
         if not code or currency not in CURRENCIES:
@@ -25,14 +26,45 @@
             if conn.execute("SELECT currency FROM accounts WHERE code=%s", (code,)).fetchone()[0] != currency:
                 raise LedgerError("currency mismatch")
 
+    def _validate(self, conn, lines):
+        validate_lines(lines)
+        totals = defaultdict(int)
+        for line in lines:
+            account = conn.execute("SELECT currency FROM accounts WHERE code=%s", (line.account_code,)).fetchone()
+            if account is None:
+                raise UnknownAccount(line.account_code)
+            totals[account[0]] += line.amount_minor * (1 if line.side == "debit" else -1)
+        if any(totals.values()):
+            raise UnbalancedTransaction("per-currency sums must balance")
+
+    def _insert(self, conn, lines, memo, reversal_of=None):
+        txn = conn.execute("INSERT INTO transactions(memo,reversal_of) VALUES (%s,%s) RETURNING id",
+                           (memo, reversal_of)).fetchone()[0]
+        for line in lines:
+            conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
+                         (txn, line.account_code, line.side, line.amount_minor))
+        return txn
+
     def post(self, lines, memo):
-        validate_lines(lines)
         with self.connect() as conn:
-            txn = conn.execute("INSERT INTO transactions(memo) VALUES (%s) RETURNING id", (memo,)).fetchone()[0]
-            for line in lines:
-                conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
-                             (txn, line.account_code, line.side, line.amount_minor))
-            return txn
+            self._validate(conn, lines)
+            return self._insert(conn, lines, memo)
+
+    def reverse(self, txn_id, memo):
+        with self.connect() as conn:
+            row = conn.execute("SELECT reversal_of,reversed_by FROM transactions WHERE id=%s FOR UPDATE",
+                               (txn_id,)).fetchone()
+            if row is None:
+                raise LedgerError("unknown transaction")
+            if row[0] is not None:
+                raise CannotReverseReversal(txn_id)
+            if row[1] is not None:
+                raise AlreadyReversed(txn_id)
+            rows = conn.execute("SELECT code,side,amount FROM lines WHERE txn=%s", (txn_id,)).fetchall()
+            opposite = [Line(code, "credit" if side == "debit" else "debit", amount) for code, side, amount in rows]
+            reversal = self._insert(conn, opposite, memo, txn_id)
+            conn.execute("UPDATE transactions SET reversed_by=%s WHERE id=%s", (reversal, txn_id))
+            return reversal
 
     def balance(self, account_code):
         with self.connect() as conn:

--- starter/ledger\service.py
+++ alt_valid/ledger\service.py
@@ -1,7 +1,9 @@
+import json
 import psycopg
 from ledger.models import (Line, LedgerError, UnbalancedTransaction, InvalidAmount, UnknownAccount,
                            AlreadyReversed, CannotReverseReversal, CURRENCIES, validate_lines)  # noqa: F401
-from ledger.schema import SCHEMA
+
+RECORDS = "jsonb_to_recordset(%s::jsonb) AS x(account_code text, side text, amount_minor bigint)"
 
 
 __all__ = ["LedgerService", "Line", "LedgerError", "UnbalancedTransaction", "InvalidAmount",
@@ -10,41 +12,72 @@
 
 class LedgerService:
     def __init__(self, database_url):
-        self.url = database_url
-        with self.connect() as conn:
-            conn.execute(SCHEMA)
-
-    def connect(self):
-        return psycopg.connect(self.url, autocommit=True)
+        self.dsn = database_url
+        with psycopg.connect(self.dsn) as c:
+            c.execute("""CREATE TABLE IF NOT EXISTS journal_accounts(name text PRIMARY KEY, denomination text);
+                CREATE TABLE IF NOT EXISTS journal_batches(number bigserial PRIMARY KEY, note text,
+                    undoes bigint, undone_by bigint);
+                CREATE TABLE IF NOT EXISTS journal_lines(batch bigint, account text, direction text, value bigint)""")
 
     def create_account(self, code, currency):
         if not code or currency not in CURRENCIES:
             raise LedgerError("invalid account")
-        with self.connect() as conn:
-            conn.execute("INSERT INTO accounts VALUES (%s,%s) ON CONFLICT DO NOTHING", (code, currency))
-            if conn.execute("SELECT currency FROM accounts WHERE code=%s", (code,)).fetchone()[0] != currency:
-                raise LedgerError("currency mismatch")
+        with psycopg.connect(self.dsn) as c:
+            c.execute("INSERT INTO journal_accounts VALUES (%s,%s) ON CONFLICT DO NOTHING", (code, currency))
+            stored, = c.execute("SELECT denomination FROM journal_accounts WHERE name=%s", (code,)).fetchone()
+            if stored != currency:
+                raise LedgerError("account already has a different denomination")
 
     def post(self, lines, memo):
         validate_lines(lines)
-        with self.connect() as conn:
-            txn = conn.execute("INSERT INTO transactions(memo) VALUES (%s) RETURNING id", (memo,)).fetchone()[0]
-            for line in lines:
-                conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
-                             (txn, line.account_code, line.side, line.amount_minor))
-            return txn
+        payload = json.dumps([line.as_dict() for line in lines])
+        with psycopg.connect(self.dsn) as c:
+            absent = c.execute("SELECT x.account_code FROM " + RECORDS +
+                               " LEFT JOIN journal_accounts a ON a.name=x.account_code WHERE a.name IS NULL",
+                               (payload,)).fetchone()
+            if absent:
+                raise UnknownAccount(absent[0])
+            imbalance = c.execute("SELECT a.denomination FROM " + RECORDS +
+                                  " JOIN journal_accounts a ON a.name=x.account_code GROUP BY a.denomination "
+                                  "HAVING SUM(CASE WHEN x.side='debit' THEN x.amount_minor ELSE -x.amount_minor END)<>0",
+                                  (payload,)).fetchone()
+            if imbalance:
+                raise UnbalancedTransaction("denomination totals differ")
+            number, = c.execute("INSERT INTO journal_batches(note) VALUES (%s) RETURNING number", (memo,)).fetchone()
+            c.execute("INSERT INTO journal_lines SELECT %s,x.account_code,x.side,x.amount_minor FROM " + RECORDS,
+                      (number, payload))
+            return number
+
+    def reverse(self, txn_id, memo):
+        with psycopg.connect(self.dsn) as c:
+            info = c.execute("SELECT undoes,undone_by FROM journal_batches WHERE number=%s FOR UPDATE", (txn_id,)).fetchone()
+            if info is None:
+                raise LedgerError("transaction not found")
+            original, prior = info
+            if original is not None:
+                raise CannotReverseReversal(txn_id)
+            if prior is not None:
+                raise AlreadyReversed(txn_id)
+            number, = c.execute("INSERT INTO journal_batches(note,undoes) VALUES (%s,%s) RETURNING number", (memo, txn_id)).fetchone()
+            c.execute("""INSERT INTO journal_lines SELECT %s,account,
+                CASE direction WHEN 'debit' THEN 'credit' ELSE 'debit' END,value
+                FROM journal_lines WHERE batch=%s""", (number, txn_id))
+            c.execute("UPDATE journal_batches SET undone_by=%s WHERE number=%s", (number, txn_id))
+            return number
 
     def balance(self, account_code):
-        with self.connect() as conn:
-            if conn.execute("SELECT 1 FROM accounts WHERE code=%s", (account_code,)).fetchone() is None:
+        with psycopg.connect(self.dsn) as c:
+            exists = c.execute("SELECT 1 FROM journal_accounts WHERE name=%s", (account_code,)).fetchone()
+            if not exists:
                 raise UnknownAccount(account_code)
-            return int(conn.execute("""SELECT COALESCE(SUM(CASE WHEN side='debit' THEN amount ELSE -amount END),0)
-                FROM lines WHERE code=%s""", (account_code,)).fetchone()[0])
+            value, = c.execute("""SELECT COALESCE(SUM(value * CASE direction WHEN 'debit' THEN 1 ELSE -1 END),0)
+                FROM journal_lines WHERE account=%s""", (account_code,)).fetchone()
+            return int(value)
 
     def trial_balance(self):
-        with self.connect() as conn:
-            rows = conn.execute("""SELECT a.currency,
-                COALESCE(SUM(l.amount) FILTER (WHERE l.side='debit'),0),
-                COALESCE(SUM(l.amount) FILTER (WHERE l.side='credit'),0)
-                FROM accounts a LEFT JOIN lines l ON a.code=l.code GROUP BY a.currency""").fetchall()
-        return {currency: (int(debit), int(credit)) for currency, debit, credit in rows}
+        with psycopg.connect(self.dsn) as c:
+            rows = c.execute("""SELECT denomination,
+                COALESCE(SUM(CASE WHEN direction='debit' THEN value ELSE 0 END),0),
+                COALESCE(SUM(CASE WHEN direction='credit' THEN value ELSE 0 END),0)
+                FROM journal_accounts LEFT JOIN journal_lines ON name=account GROUP BY denomination""").fetchall()
+        return {row[0]: tuple(map(int, row[1:])) for row in rows}

--- starter/ledger\schema.py
+++ wrong_cross_currency_sum/ledger\schema.py
@@ -2,7 +2,11 @@
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS accounts(code text PRIMARY KEY, currency text NOT NULL);
-CREATE TABLE IF NOT EXISTS transactions(id bigserial PRIMARY KEY, memo text);
+CREATE TABLE IF NOT EXISTS transactions(
+    id bigserial PRIMARY KEY,
+    memo text,
+    reversal_of bigint REFERENCES transactions(id),
+    reversed_by bigint);
 CREATE TABLE IF NOT EXISTS lines(
     txn bigint REFERENCES transactions(id),
     code text REFERENCES accounts(code),
--- starter/ledger\service.py
+++ wrong_cross_currency_sum/ledger\service.py
@@ -1,3 +1,4 @@
+from collections import defaultdict
 import psycopg
 from ledger.models import (Line, LedgerError, UnbalancedTransaction, InvalidAmount, UnknownAccount,
                            AlreadyReversed, CannotReverseReversal, CURRENCIES, validate_lines)  # noqa: F401
@@ -15,7 +16,7 @@
             conn.execute(SCHEMA)
 
     def connect(self):
-        return psycopg.connect(self.url, autocommit=True)
+        return psycopg.connect(self.url)
 
     def create_account(self, code, currency):
         if not code or currency not in CURRENCIES:
@@ -25,14 +26,45 @@
             if conn.execute("SELECT currency FROM accounts WHERE code=%s", (code,)).fetchone()[0] != currency:
                 raise LedgerError("currency mismatch")
 
+    def _validate(self, conn, lines):
+        validate_lines(lines)
+        totals = defaultdict(int)
+        for line in lines:
+            account = conn.execute("SELECT currency FROM accounts WHERE code=%s", (line.account_code,)).fetchone()
+            if account is None:
+                raise UnknownAccount(line.account_code)
+            totals["all"] += line.amount_minor * (1 if line.side == "debit" else -1)
+        if any(totals.values()):
+            raise UnbalancedTransaction("per-currency sums must balance")
+
+    def _insert(self, conn, lines, memo, reversal_of=None):
+        txn = conn.execute("INSERT INTO transactions(memo,reversal_of) VALUES (%s,%s) RETURNING id",
+                           (memo, reversal_of)).fetchone()[0]
+        for line in lines:
+            conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
+                         (txn, line.account_code, line.side, line.amount_minor))
+        return txn
+
     def post(self, lines, memo):
-        validate_lines(lines)
         with self.connect() as conn:
-            txn = conn.execute("INSERT INTO transactions(memo) VALUES (%s) RETURNING id", (memo,)).fetchone()[0]
-            for line in lines:
-                conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
-                             (txn, line.account_code, line.side, line.amount_minor))
-            return txn
+            self._validate(conn, lines)
+            return self._insert(conn, lines, memo)
+
+    def reverse(self, txn_id, memo):
+        with self.connect() as conn:
+            row = conn.execute("SELECT reversal_of,reversed_by FROM transactions WHERE id=%s FOR UPDATE",
+                               (txn_id,)).fetchone()
+            if row is None:
+                raise LedgerError("unknown transaction")
+            if row[0] is not None:
+                raise CannotReverseReversal(txn_id)
+            if row[1] is not None:
+                raise AlreadyReversed(txn_id)
+            rows = conn.execute("SELECT code,side,amount FROM lines WHERE txn=%s", (txn_id,)).fetchall()
+            opposite = [Line(code, "credit" if side == "debit" else "debit", amount) for code, side, amount in rows]
+            reversal = self._insert(conn, opposite, memo, txn_id)
+            conn.execute("UPDATE transactions SET reversed_by=%s WHERE id=%s", (reversal, txn_id))
+            return reversal
 
     def balance(self, account_code):
         with self.connect() as conn:

--- starter/ledger\schema.py
+++ wrong_double_reverse/ledger\schema.py
@@ -2,7 +2,11 @@
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS accounts(code text PRIMARY KEY, currency text NOT NULL);
-CREATE TABLE IF NOT EXISTS transactions(id bigserial PRIMARY KEY, memo text);
+CREATE TABLE IF NOT EXISTS transactions(
+    id bigserial PRIMARY KEY,
+    memo text,
+    reversal_of bigint REFERENCES transactions(id),
+    reversed_by bigint);
 CREATE TABLE IF NOT EXISTS lines(
     txn bigint REFERENCES transactions(id),
     code text REFERENCES accounts(code),
--- starter/ledger\service.py
+++ wrong_double_reverse/ledger\service.py
@@ -1,3 +1,4 @@
+from collections import defaultdict
 import psycopg
 from ledger.models import (Line, LedgerError, UnbalancedTransaction, InvalidAmount, UnknownAccount,
                            AlreadyReversed, CannotReverseReversal, CURRENCIES, validate_lines)  # noqa: F401
@@ -15,7 +16,7 @@
             conn.execute(SCHEMA)
 
     def connect(self):
-        return psycopg.connect(self.url, autocommit=True)
+        return psycopg.connect(self.url)
 
     def create_account(self, code, currency):
         if not code or currency not in CURRENCIES:
@@ -25,14 +26,43 @@
             if conn.execute("SELECT currency FROM accounts WHERE code=%s", (code,)).fetchone()[0] != currency:
                 raise LedgerError("currency mismatch")
 
+    def _validate(self, conn, lines):
+        validate_lines(lines)
+        totals = defaultdict(int)
+        for line in lines:
+            account = conn.execute("SELECT currency FROM accounts WHERE code=%s", (line.account_code,)).fetchone()
+            if account is None:
+                raise UnknownAccount(line.account_code)
+            totals[account[0]] += line.amount_minor * (1 if line.side == "debit" else -1)
+        if any(totals.values()):
+            raise UnbalancedTransaction("per-currency sums must balance")
+
+    def _insert(self, conn, lines, memo, reversal_of=None):
+        txn = conn.execute("INSERT INTO transactions(memo,reversal_of) VALUES (%s,%s) RETURNING id",
+                           (memo, reversal_of)).fetchone()[0]
+        for line in lines:
+            conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
+                         (txn, line.account_code, line.side, line.amount_minor))
+        return txn
+
     def post(self, lines, memo):
-        validate_lines(lines)
         with self.connect() as conn:
-            txn = conn.execute("INSERT INTO transactions(memo) VALUES (%s) RETURNING id", (memo,)).fetchone()[0]
-            for line in lines:
-                conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
-                             (txn, line.account_code, line.side, line.amount_minor))
-            return txn
+            self._validate(conn, lines)
+            return self._insert(conn, lines, memo)
+
+    def reverse(self, txn_id, memo):
+        with self.connect() as conn:
+            row = conn.execute("SELECT reversal_of,reversed_by FROM transactions WHERE id=%s FOR UPDATE",
+                               (txn_id,)).fetchone()
+            if row is None:
+                raise LedgerError("unknown transaction")
+            if row[0] is not None:
+                raise CannotReverseReversal(txn_id)
+            rows = conn.execute("SELECT code,side,amount FROM lines WHERE txn=%s", (txn_id,)).fetchall()
+            opposite = [Line(code, "credit" if side == "debit" else "debit", amount) for code, side, amount in rows]
+            reversal = self._insert(conn, opposite, memo, txn_id)
+            conn.execute("UPDATE transactions SET reversed_by=%s WHERE id=%s", (reversal, txn_id))
+            return reversal
 
     def balance(self, account_code):
         with self.connect() as conn:

--- starter/ledger\schema.py
+++ wrong_non_atomic/ledger\schema.py
@@ -2,7 +2,11 @@
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS accounts(code text PRIMARY KEY, currency text NOT NULL);
-CREATE TABLE IF NOT EXISTS transactions(id bigserial PRIMARY KEY, memo text);
+CREATE TABLE IF NOT EXISTS transactions(
+    id bigserial PRIMARY KEY,
+    memo text,
+    reversal_of bigint REFERENCES transactions(id),
+    reversed_by bigint);
 CREATE TABLE IF NOT EXISTS lines(
     txn bigint REFERENCES transactions(id),
     code text REFERENCES accounts(code),
--- starter/ledger\service.py
+++ wrong_non_atomic/ledger\service.py
@@ -1,3 +1,4 @@
+from collections import defaultdict
 import psycopg
 from ledger.models import (Line, LedgerError, UnbalancedTransaction, InvalidAmount, UnknownAccount,
                            AlreadyReversed, CannotReverseReversal, CURRENCIES, validate_lines)  # noqa: F401
@@ -25,14 +26,46 @@
             if conn.execute("SELECT currency FROM accounts WHERE code=%s", (code,)).fetchone()[0] != currency:
                 raise LedgerError("currency mismatch")
 
+    def _insert(self, conn, lines, memo, reversal_of=None):
+        txn = conn.execute("INSERT INTO transactions(memo,reversal_of) VALUES (%s,%s) RETURNING id",
+                           (memo, reversal_of)).fetchone()[0]
+        for line in lines:
+            conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
+                         (txn, line.account_code, line.side, line.amount_minor))
+        return txn
+
     def post(self, lines, memo):
         validate_lines(lines)
         with self.connect() as conn:
             txn = conn.execute("INSERT INTO transactions(memo) VALUES (%s) RETURNING id", (memo,)).fetchone()[0]
+            totals = defaultdict(int)
             for line in lines:
+                account = conn.execute("SELECT currency FROM accounts WHERE code=%s",
+                                       (line.account_code,)).fetchone()
+                if account is None:
+                    raise UnknownAccount(line.account_code)
+                totals[account[0]] += line.amount_minor * (1 if line.side == "debit" else -1)
                 conn.execute("INSERT INTO lines VALUES (%s,%s,%s,%s)",
                              (txn, line.account_code, line.side, line.amount_minor))
+            if any(totals.values()):
+                raise UnbalancedTransaction("per-currency sums must balance")
             return txn
+
+    def reverse(self, txn_id, memo):
+        with self.connect() as conn:
+            row = conn.execute("SELECT reversal_of,reversed_by FROM transactions WHERE id=%s FOR UPDATE",
+                               (txn_id,)).fetchone()
+            if row is None:
+                raise LedgerError("unknown transaction")
+            if row[0] is not None:
+                raise CannotReverseReversal(txn_id)
+            if row[1] is not None:
+                raise AlreadyReversed(txn_id)
+            rows = conn.execute("SELECT code,side,amount FROM lines WHERE txn=%s", (txn_id,)).fetchall()
+            opposite = [Line(code, "credit" if side == "debit" else "debit", amount) for code, side, amount in rows]
+            reversal = self._insert(conn, opposite, memo, txn_id)
+            conn.execute("UPDATE transactions SET reversed_by=%s WHERE id=%s", (reversal, txn_id))
+            return reversal
 
     def balance(self, account_code):
         with self.connect() as conn:

--- starter/holds\main.py
+++ reference/holds\main.py
@@ -3,7 +3,7 @@
 from fastapi.responses import JSONResponse
 from holds.clock import instant
 from holds.errors import error
-from holds.storage import transaction, initialize, account
+from holds.storage import transaction, initialize, account, authorization, active_total, HOLD_SECONDS
 from holds.validation import amount
 
 
@@ -18,7 +18,7 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            return {"posted_minor": row["posted"], "available_minor": row["posted"]}
+            return {"posted_minor": row["posted"], "available_minor": row["posted"] - active_total(db, id, instant(clock))}
 
     @api.post("/accounts/{id}/authorizations")
     async def authorize(id: str, request: Request):
@@ -30,9 +30,34 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            if value > row["posted"] + row["overdraft"]:
+            available = row["posted"] - active_total(db, id, now)
+            if value > available + row["overdraft"]:
                 return error(402, "insufficient_funds")
             identifier = uuid4().hex
             db.execute("INSERT INTO authorizations VALUES (?,?,?,?,'active')", (identifier, id, value, now))
             return JSONResponse({"auth_id": identifier}, status_code=201)
+
+    def close(id, capture=None):
+        with transaction(database_path) as db:
+            auth = authorization(db, id)
+            if auth is None:
+                return error(404, "not_found")
+            if auth["state"] != "active" or instant(clock) >= auth["created"] + HOLD_SECONDS:
+                return error(409, "authorization_closed")
+            if capture is not None:
+                if capture > auth["amount"]:
+                    return error(422, "capture_exceeds_hold")
+                db.execute("UPDATE accounts SET posted=posted-? WHERE id=?", (capture, auth["account"]))
+            state = "captured" if capture is not None else "voided"
+            db.execute("UPDATE authorizations SET state=? WHERE id=?", (state, id))
+            return {"auth_id": id, "status": state}
+
+    @api.post("/authorizations/{id}/capture")
+    async def capture(id: str, request: Request):
+        value = await amount(request)
+        return error(422, "invalid_amount") if value is None else close(id, value)
+
+    @api.post("/authorizations/{id}/void")
+    def void(id: str):
+        return close(id)
     return api
--- starter/holds\storage.py
+++ reference/holds\storage.py
@@ -24,6 +24,15 @@
         seed_accounts(db)
 
 
+HOLD_SECONDS = 7 * 86400
+
+
+def active_total(db, account, now):
+    """Sum of the account's active holds that have not yet expired at `now` (epoch seconds)."""
+    return db.execute("""SELECT COALESCE(SUM(amount),0) FROM authorizations
+        WHERE account=? AND state='active' AND created>?""", (account, now - HOLD_SECONDS)).fetchone()[0]
+
+
 def account(db, identifier):
     return db.execute("SELECT * FROM accounts WHERE id=?", (identifier,)).fetchone()
 

--- starter/holds\main.py
+++ alt_valid/holds\main.py
@@ -1,38 +1,86 @@
+from contextlib import contextmanager
 from uuid import uuid4
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from holds.clock import instant
-from holds.errors import error
-from holds.storage import transaction, initialize, account
-from holds.validation import amount
+from holds.storage import initialize, transaction
 
 
 def create_app(database_path, clock):
     initialize(database_path)
     instant(clock)
-    api = FastAPI()
+    application = FastAPI()
 
-    @api.get("/accounts/{id}/balance")
-    def balance(id: str):
-        with transaction(database_path) as db:
-            row = account(db, id)
-            if row is None:
-                return error(404, "not_found")
-            return {"posted_minor": row["posted"], "available_minor": row["posted"]}
+    def failure(status, code):
+        return JSONResponse({"error": {"code": code, "message": code}}, status_code=status)
 
-    @api.post("/accounts/{id}/authorizations")
-    async def authorize(id: str, request: Request):
-        value = await amount(request)
-        if value is None:
-            return error(422, "invalid_amount")
-        now = instant(clock)
-        with transaction(database_path) as db:
-            row = account(db, id)
-            if row is None:
-                return error(404, "not_found")
-            if value > row["posted"] + row["overdraft"]:
-                return error(402, "insufficient_funds")
-            identifier = uuid4().hex
-            db.execute("INSERT INTO authorizations VALUES (?,?,?,?,'active')", (identifier, id, value, now))
-            return JSONResponse({"auth_id": identifier}, status_code=201)
-    return api
+    @contextmanager
+    def current_state():
+        with transaction(database_path) as connection:
+            connection.execute("UPDATE authorizations SET state='expired' WHERE state='active' AND created<=?",
+                               [instant(clock) - 604800])
+            yield connection
+
+    async def number(request):
+        try:
+            payload = await request.json()
+            if isinstance(payload, dict) and set(payload) == {"amount_minor"}:
+                n = payload["amount_minor"]
+                if type(n) is int and n > 0:
+                    return n
+        except ValueError:
+            pass
+        return None
+
+    def funds(db, id):
+        result = db.execute("SELECT posted,overdraft FROM accounts WHERE id=?", [id]).fetchone()
+        if result is None:
+            return None
+        total, = db.execute("SELECT COALESCE(SUM(amount),0) FROM authorizations WHERE account=? AND state='active'", [id]).fetchone()
+        return result[0], result[0] - total, result[1]
+
+    @application.get("/accounts/{id}/balance")
+    def get_balance(id: str):
+        with current_state() as db:
+            totals = funds(db, id)
+            return failure(404, "not_found") if totals is None else {"posted_minor": totals[0], "available_minor": totals[1]}
+
+    @application.post("/accounts/{id}/authorizations")
+    async def reserve(id: str, request: Request):
+        n = await number(request)
+        if n is None:
+            return failure(422, "invalid_amount")
+        with current_state() as db:
+            totals = funds(db, id)
+            if totals is None:
+                return failure(404, "not_found")
+            if n > totals[1] + totals[2]:
+                return failure(402, "insufficient_funds")
+            key = str(uuid4())
+            db.execute("INSERT INTO authorizations VALUES (?,?,?,?,'active')", [key, id, n, instant(clock)])
+            return JSONResponse({"auth_id": key}, status_code=201)
+
+    def mutate(key, action, n=0):
+        with current_state() as db:
+            record = db.execute("SELECT account,amount,state FROM authorizations WHERE id=?", [key]).fetchone()
+            if record is None:
+                return failure(404, "not_found")
+            owner, reserved, status = record
+            if status != "active":
+                return failure(409, "authorization_closed")
+            if action == "captured":
+                if n > reserved:
+                    return failure(422, "capture_exceeds_hold")
+                db.execute("UPDATE accounts SET posted=posted-? WHERE id=?", [n, owner])
+            db.execute("UPDATE authorizations SET state=? WHERE id=?", [action, key])
+            return {"auth_id": key, "status": action}
+
+    @application.post("/authorizations/{id}/capture")
+    async def settle(id: str, request: Request):
+        n = await number(request)
+        return failure(422, "invalid_amount") if n is None else mutate(id, "captured", n)
+
+    @application.post("/authorizations/{id}/void")
+    def release(id: str):
+        return mutate(id, "voided")
+    return application

--- starter/holds\main.py
+++ wrong_available_ignores_holds/holds\main.py
@@ -3,7 +3,7 @@
 from fastapi.responses import JSONResponse
 from holds.clock import instant
 from holds.errors import error
-from holds.storage import transaction, initialize, account
+from holds.storage import transaction, initialize, account, authorization, HOLD_SECONDS
 from holds.validation import amount
 
 
@@ -30,9 +30,34 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            if value > row["posted"] + row["overdraft"]:
+            available = row["posted"]
+            if value > available + row["overdraft"]:
                 return error(402, "insufficient_funds")
             identifier = uuid4().hex
             db.execute("INSERT INTO authorizations VALUES (?,?,?,?,'active')", (identifier, id, value, now))
             return JSONResponse({"auth_id": identifier}, status_code=201)
+
+    def close(id, capture=None):
+        with transaction(database_path) as db:
+            auth = authorization(db, id)
+            if auth is None:
+                return error(404, "not_found")
+            if auth["state"] != "active" or instant(clock) >= auth["created"] + HOLD_SECONDS:
+                return error(409, "authorization_closed")
+            if capture is not None:
+                if capture > auth["amount"]:
+                    return error(422, "capture_exceeds_hold")
+                db.execute("UPDATE accounts SET posted=posted-? WHERE id=?", (capture, auth["account"]))
+            state = "captured" if capture is not None else "voided"
+            db.execute("UPDATE authorizations SET state=? WHERE id=?", (state, id))
+            return {"auth_id": id, "status": state}
+
+    @api.post("/authorizations/{id}/capture")
+    async def capture(id: str, request: Request):
+        value = await amount(request)
+        return error(422, "invalid_amount") if value is None else close(id, value)
+
+    @api.post("/authorizations/{id}/void")
+    def void(id: str):
+        return close(id)
     return api
--- starter/holds\storage.py
+++ wrong_available_ignores_holds/holds\storage.py
@@ -24,6 +24,15 @@
         seed_accounts(db)
 
 
+HOLD_SECONDS = 7 * 86400
+
+
+def active_total(db, account, now):
+    """Sum of the account's active holds that have not yet expired at `now` (epoch seconds)."""
+    return db.execute("""SELECT COALESCE(SUM(amount),0) FROM authorizations
+        WHERE account=? AND state='active' AND created>?""", (account, now - HOLD_SECONDS)).fetchone()[0]
+
+
 def account(db, identifier):
     return db.execute("SELECT * FROM accounts WHERE id=?", (identifier,)).fetchone()
 

--- starter/holds\main.py
+++ wrong_expired_holds_count/holds\main.py
@@ -3,7 +3,7 @@
 from fastapi.responses import JSONResponse
 from holds.clock import instant
 from holds.errors import error
-from holds.storage import transaction, initialize, account
+from holds.storage import transaction, initialize, account, authorization, active_total, HOLD_SECONDS
 from holds.validation import amount
 
 
@@ -18,7 +18,7 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            return {"posted_minor": row["posted"], "available_minor": row["posted"]}
+            return {"posted_minor": row["posted"], "available_minor": row["posted"] - active_total(db, id, instant(clock))}
 
     @api.post("/accounts/{id}/authorizations")
     async def authorize(id: str, request: Request):
@@ -30,9 +30,34 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            if value > row["posted"] + row["overdraft"]:
+            available = row["posted"] - active_total(db, id, now)
+            if value > available + row["overdraft"]:
                 return error(402, "insufficient_funds")
             identifier = uuid4().hex
             db.execute("INSERT INTO authorizations VALUES (?,?,?,?,'active')", (identifier, id, value, now))
             return JSONResponse({"auth_id": identifier}, status_code=201)
+
+    def close(id, capture=None):
+        with transaction(database_path) as db:
+            auth = authorization(db, id)
+            if auth is None:
+                return error(404, "not_found")
+            if auth["state"] != "active" or instant(clock) >= auth["created"] + HOLD_SECONDS:
+                return error(409, "authorization_closed")
+            if capture is not None:
+                if capture > auth["amount"]:
+                    return error(422, "capture_exceeds_hold")
+                db.execute("UPDATE accounts SET posted=posted-? WHERE id=?", (capture, auth["account"]))
+            state = "captured" if capture is not None else "voided"
+            db.execute("UPDATE authorizations SET state=? WHERE id=?", (state, id))
+            return {"auth_id": id, "status": state}
+
+    @api.post("/authorizations/{id}/capture")
+    async def capture(id: str, request: Request):
+        value = await amount(request)
+        return error(422, "invalid_amount") if value is None else close(id, value)
+
+    @api.post("/authorizations/{id}/void")
+    def void(id: str):
+        return close(id)
     return api
--- starter/holds\storage.py
+++ wrong_expired_holds_count/holds\storage.py
@@ -24,6 +24,15 @@
         seed_accounts(db)
 
 
+HOLD_SECONDS = 7 * 86400
+
+
+def active_total(db, account, now):
+    """Sum of the account's active holds that have not yet expired at `now` (epoch seconds)."""
+    return db.execute("""SELECT COALESCE(SUM(amount),0) FROM authorizations
+        WHERE account=? AND state='active'""", (account,)).fetchone()[0]
+
+
 def account(db, identifier):
     return db.execute("SELECT * FROM accounts WHERE id=?", (identifier,)).fetchone()
 

--- starter/holds\main.py
+++ wrong_partial_capture_keeps_remainder/holds\main.py
@@ -3,7 +3,7 @@
 from fastapi.responses import JSONResponse
 from holds.clock import instant
 from holds.errors import error
-from holds.storage import transaction, initialize, account
+from holds.storage import transaction, initialize, account, authorization, active_total, HOLD_SECONDS
 from holds.validation import amount
 
 
@@ -18,7 +18,7 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            return {"posted_minor": row["posted"], "available_minor": row["posted"]}
+            return {"posted_minor": row["posted"], "available_minor": row["posted"] - active_total(db, id, instant(clock))}
 
     @api.post("/accounts/{id}/authorizations")
     async def authorize(id: str, request: Request):
@@ -30,9 +30,37 @@
             row = account(db, id)
             if row is None:
                 return error(404, "not_found")
-            if value > row["posted"] + row["overdraft"]:
+            available = row["posted"] - active_total(db, id, now)
+            if value > available + row["overdraft"]:
                 return error(402, "insufficient_funds")
             identifier = uuid4().hex
             db.execute("INSERT INTO authorizations VALUES (?,?,?,?,'active')", (identifier, id, value, now))
             return JSONResponse({"auth_id": identifier}, status_code=201)
+
+    def close(id, capture=None):
+        with transaction(database_path) as db:
+            auth = authorization(db, id)
+            if auth is None:
+                return error(404, "not_found")
+            if auth["state"] != "active" or instant(clock) >= auth["created"] + HOLD_SECONDS:
+                return error(409, "authorization_closed")
+            if capture is not None:
+                if capture > auth["amount"]:
+                    return error(422, "capture_exceeds_hold")
+                db.execute("UPDATE accounts SET posted=posted-? WHERE id=?", (capture, auth["account"]))
+            state = "captured" if capture is not None else "voided"
+            if capture is not None and capture < auth["amount"]:
+                db.execute("UPDATE authorizations SET amount=amount-? WHERE id=?", (capture, id))
+            else:
+                db.execute("UPDATE authorizations SET state=? WHERE id=?", (state, id))
+            return {"auth_id": id, "status": state}
+
+    @api.post("/authorizations/{id}/capture")
+    async def capture(id: str, request: Request):
+        value = await amount(request)
+        return error(422, "invalid_amount") if value is None else close(id, value)
+
+    @api.post("/authorizations/{id}/void")
+    def void(id: str):
+        return close(id)
     return api
--- starter/holds\storage.py
+++ wrong_partial_capture_keeps_remainder/holds\storage.py
@@ -24,6 +24,15 @@
         seed_accounts(db)
 
 
+HOLD_SECONDS = 7 * 86400
+
+
+def active_total(db, account, now):
+    """Sum of the account's active holds that have not yet expired at `now` (epoch seconds)."""
+    return db.execute("""SELECT COALESCE(SUM(amount),0) FROM authorizations
+        WHERE account=? AND state='active' AND created>?""", (account, now - HOLD_SECONDS)).fetchone()[0]
+
+
 def account(db, identifier):
     return db.execute("SELECT * FROM accounts WHERE id=?", (identifier,)).fetchone()
 

--- starter/statements\period.py
+++ reference/statements\period.py
@@ -1,5 +1,22 @@
 from datetime import datetime, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 from statements.models import Txn  # noqa: F401
+
+MIN_YEAR, MAX_YEAR = 1900, 2098
+
+
+def load_zone(account_tz):
+    try:
+        return ZoneInfo(account_tz)
+    except (ZoneInfoNotFoundError, ValueError, TypeError, OSError) as exc:
+        raise ValueError(f"unknown time zone: {account_tz!r}") from exc
+
+
+def check_month(year, month):
+    if type(year) is not int or type(month) is not int:
+        raise ValueError("integer year and month required")
+    if not MIN_YEAR <= year <= MAX_YEAR or not 1 <= month <= 12:
+        raise ValueError("month out of range")
 
 
 def month_start(zone, year, month):
@@ -11,9 +28,11 @@
 
 
 def period_bounds(account_tz, year, month):
-    start = month_start(timezone.utc, year, month)
-    end = month_start(timezone.utc, year + (month == 12), month % 12 + 1)
-    return start, end
+    check_month(year, month)
+    zone = load_zone(account_tz)
+    start = month_start(zone, year, month)
+    end = month_start(zone, year + (month == 12), month % 12 + 1)
+    return start.astimezone(timezone.utc), end.astimezone(timezone.utc)
 
 
 def select(txns, account_tz, year, month):
@@ -22,4 +41,4 @@
         if txn.at.tzinfo is None or txn.at.utcoffset() is None:
             raise ValueError("aware timestamps required")
     chosen = [t for t in txns if start <= instant(t) < end]
-    return [t.id for t in sorted(chosen, key=instant)]
+    return [t.id for t in sorted(chosen, key=lambda t: (instant(t), t.id))]

--- starter/statements\period.py
+++ alt_valid/statements\period.py
@@ -1,25 +1,41 @@
-from datetime import datetime, timezone
+import calendar
+from datetime import datetime, timedelta, timezone
+from zoneinfo import ZoneInfo
 from statements.models import Txn  # noqa: F401
 
 
-def month_start(zone, year, month):
-    return datetime(year, month, 1, tzinfo=zone)
+def zone_for(name):
+    try:
+        return ZoneInfo(name)
+    except Exception as exc:
+        raise ValueError(f"cannot use time zone {name!r}") from exc
 
 
-def instant(txn):
-    return txn.at.astimezone(timezone.utc)
+def validated(year, month):
+    for value in (year, month):
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise ValueError("year and month must be integers")
+    if not (1900 <= year <= 2098 and 1 <= month <= 12):
+        raise ValueError("year or month outside the supported range")
 
 
 def period_bounds(account_tz, year, month):
-    start = month_start(timezone.utc, year, month)
-    end = month_start(timezone.utc, year + (month == 12), month % 12 + 1)
-    return start, end
+    validated(year, month)
+    local_first = datetime.fromisoformat(f"{year:04d}-{month:02d}-01T00:00:00").replace(tzinfo=zone_for(account_tz))
+    local_next = local_first + timedelta(days=calendar.monthrange(year, month)[1])
+    return tuple(point.astimezone(timezone.utc) for point in (local_first, local_next))
 
 
 def select(txns, account_tz, year, month):
-    start, end = period_bounds(account_tz, year, month)
-    for txn in txns:
-        if txn.at.tzinfo is None or txn.at.utcoffset() is None:
-            raise ValueError("aware timestamps required")
-    chosen = [t for t in txns if start <= instant(t) < end]
-    return [t.id for t in sorted(chosen, key=instant)]
+    validated(year, month)
+    timezone_for_account = zone_for(account_tz)
+    keyed = []
+    for item in txns:
+        stamp = item.at
+        if stamp.utcoffset() is None:
+            raise ValueError("transaction timestamp has no offset")
+        local = stamp.astimezone(timezone_for_account)
+        if (local.year, local.month) == (year, month):
+            keyed.append((stamp.astimezone(timezone.utc), item.id))
+    keyed.sort()
+    return [identifier for _, identifier in keyed]

--- starter/statements\period.py
+++ wrong_fixed_offset/statements\period.py
@@ -1,5 +1,22 @@
 from datetime import datetime, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 from statements.models import Txn  # noqa: F401
+
+MIN_YEAR, MAX_YEAR = 1900, 2098
+
+
+def load_zone(account_tz):
+    try:
+        return ZoneInfo(account_tz)
+    except (ZoneInfoNotFoundError, ValueError, TypeError, OSError) as exc:
+        raise ValueError(f"unknown time zone: {account_tz!r}") from exc
+
+
+def check_month(year, month):
+    if type(year) is not int or type(month) is not int:
+        raise ValueError("integer year and month required")
+    if not MIN_YEAR <= year <= MAX_YEAR or not 1 <= month <= 12:
+        raise ValueError("month out of range")
 
 
 def month_start(zone, year, month):
@@ -11,9 +28,13 @@
 
 
 def period_bounds(account_tz, year, month):
-    start = month_start(timezone.utc, year, month)
-    end = month_start(timezone.utc, year + (month == 12), month % 12 + 1)
-    return start, end
+    check_month(year, month)
+    iana = load_zone(account_tz)
+    january = datetime(year, 1, 1, tzinfo=iana)
+    zone = timezone(january.utcoffset() - january.dst())
+    start = month_start(zone, year, month)
+    end = month_start(zone, year + (month == 12), month % 12 + 1)
+    return start.astimezone(timezone.utc), end.astimezone(timezone.utc)
 
 
 def select(txns, account_tz, year, month):
@@ -22,4 +43,4 @@
         if txn.at.tzinfo is None or txn.at.utcoffset() is None:
             raise ValueError("aware timestamps required")
     chosen = [t for t in txns if start <= instant(t) < end]
-    return [t.id for t in sorted(chosen, key=instant)]
+    return [t.id for t in sorted(chosen, key=lambda t: (instant(t), t.id))]

--- starter/statements\period.py
+++ wrong_offset_sign/statements\period.py
@@ -1,4 +1,6 @@
 from datetime import datetime, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
 from statements.models import Txn  # noqa: F401
 
 
@@ -11,9 +13,19 @@
 
 
 def period_bounds(account_tz, year, month):
-    start = month_start(timezone.utc, year, month)
-    end = month_start(timezone.utc, year + (month == 12), month % 12 + 1)
-    return start, end
+    if type(year) is not int or type(month) is not int:
+        raise ValueError("integer year and month required")
+    if not 1900 <= year <= 2098 or not 1 <= month <= 12:
+        raise ValueError("month out of range")
+    try:
+        zone = ZoneInfo(account_tz)
+    except (ZoneInfoNotFoundError, ValueError, TypeError, OSError) as exc:
+        raise ValueError(f"unknown time zone: {account_tz!r}") from exc
+    start = month_start(zone, year, month)
+    end = month_start(zone, year + (month == 12), month % 12 + 1)
+    # Translate the local wall-clock boundaries by their respective UTC offsets.
+    return (start.replace(tzinfo=timezone.utc) + start.utcoffset(),
+            end.replace(tzinfo=timezone.utc) + end.utcoffset())
 
 
 def select(txns, account_tz, year, month):
@@ -22,4 +34,4 @@
         if txn.at.tzinfo is None or txn.at.utcoffset() is None:
             raise ValueError("aware timestamps required")
     chosen = [t for t in txns if start <= instant(t) < end]
-    return [t.id for t in sorted(chosen, key=instant)]
+    return [t.id for t in sorted(chosen, key=lambda t: (instant(t), t.id))]

--- starter/statements\period.py
+++ wrong_utc_month/statements\period.py
@@ -1,5 +1,22 @@
 from datetime import datetime, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 from statements.models import Txn  # noqa: F401
+
+MIN_YEAR, MAX_YEAR = 1900, 2098
+
+
+def load_zone(account_tz):
+    try:
+        return ZoneInfo(account_tz)
+    except (ZoneInfoNotFoundError, ValueError, TypeError, OSError) as exc:
+        raise ValueError(f"unknown time zone: {account_tz!r}") from exc
+
+
+def check_month(year, month):
+    if type(year) is not int or type(month) is not int:
+        raise ValueError("integer year and month required")
+    if not MIN_YEAR <= year <= MAX_YEAR or not 1 <= month <= 12:
+        raise ValueError("month out of range")
 
 
 def month_start(zone, year, month):
@@ -11,9 +28,11 @@
 
 
 def period_bounds(account_tz, year, month):
+    check_month(year, month)
+    load_zone(account_tz)
     start = month_start(timezone.utc, year, month)
     end = month_start(timezone.utc, year + (month == 12), month % 12 + 1)
-    return start, end
+    return start.astimezone(timezone.utc), end.astimezone(timezone.utc)
 
 
 def select(txns, account_tz, year, month):
@@ -22,4 +41,4 @@
         if txn.at.tzinfo is None or txn.at.utcoffset() is None:
             raise ValueError("aware timestamps required")
     chosen = [t for t in txns if start <= instant(t) < end]
-    return [t.id for t in sorted(chosen, key=instant)]
+    return [t.id for t in sorted(chosen, key=lambda t: (instant(t), t.id))]

--- starter/refunds\service.py
+++ reference/refunds\service.py
@@ -20,20 +20,22 @@
 
     def capture(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
-            if payment is None or amount_minor > payment.authorized:
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
+            if payment.captured is not None or amount_minor > payment.authorized:
                 raise InvalidAmount("invalid capture")
             store.set_captured(conn, id, amount_minor)
 
     def refund(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
             if payment.captured is None:
                 raise PaymentNotCaptured(id)
+            if amount_minor > payment.refundable:
+                raise RefundExceedsCaptured(id)
             return store.add_refund(conn, id, amount_minor)
 
     def refunded_total(self, id):
         with self.connect() as conn:
-            return store.get_payment(conn, id).refunded
+            return store.require_payment(conn, id).refunded
--- starter/refunds\store.py
+++ reference/refunds\store.py
@@ -1,4 +1,5 @@
 """SQLite access for payments and refunds. Each call receives the caller's connection."""
+from contextlib import contextmanager
 import sqlite3
 from dataclasses import dataclass
 
@@ -10,9 +11,29 @@
     captured: int | None
     refunded: int
 
+    @property
+    def refundable(self):
+        """Captured funds not yet refunded; zero before capture."""
+        return 0 if self.captured is None else self.captured - self.refunded
+
 
 def connect(path):
     return sqlite3.connect(str(path), timeout=30)
+
+
+@contextmanager
+def immediate(path):
+    """Write transaction that takes the database write lock up front and always closes its connection."""
+    conn = connect(path)
+    try:
+        conn.execute("BEGIN IMMEDIATE")
+        yield conn
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
 
 
 def initialize(conn):
@@ -30,6 +51,13 @@
     return PaymentRow(*row) if row else None
 
 
+def require_payment(conn, payment_id):
+    payment = get_payment(conn, payment_id)
+    if payment is None:
+        raise ValueError(f"unknown payment {payment_id!r}")
+    return payment
+
+
 def set_captured(conn, payment_id, amount_minor):
     conn.execute("UPDATE payments SET captured=? WHERE id=?", (amount_minor, payment_id))
 

--- starter/refunds\service.py
+++ alt_valid/refunds\service.py
@@ -1,39 +1,80 @@
-from refunds import store
+import json
+import sqlite3
+from contextlib import contextmanager
 from refunds.models import RefundExceedsCaptured, PaymentNotCaptured, InvalidAmount, validate_amount
 
 __all__ = ["RefundService", "RefundExceedsCaptured", "PaymentNotCaptured", "InvalidAmount"]
 
 
+@contextmanager
+def journal(filename):
+    connection = sqlite3.connect(filename)
+    try:
+        with connection:
+            connection.execute("BEGIN IMMEDIATE")
+            yield connection
+    finally:
+        connection.close()
+
+
+def append(connection, tag, owner, payload):
+    inserted = connection.execute("INSERT INTO event_log(tag,owner,payload) VALUES (?,?,?)",
+                                  [tag, owner, json.dumps(payload)])
+    return inserted.lastrowid
+
+
+def known_state(connection, number):
+    state = reconstruct(connection, number)
+    if not state["known"]:
+        raise ValueError(f"unknown payment {number!r}")
+    return state
+
+
+def reconstruct(connection, number):
+    state = {"known": False, "ceiling": 0, "settled": None, "returned": 0}
+    history = connection.execute("SELECT tag,payload FROM event_log WHERE number=? OR owner=? ORDER BY number",
+                                 [number, number])
+    for tag, payload in history:
+        value = json.loads(payload)["minor"]
+        if tag == "approval":
+            state["known"] = True
+            state["ceiling"] = value
+        elif tag == "settlement":
+            state["settled"] = value
+        elif tag == "credit":
+            state["returned"] += value
+    return state
+
+
 class RefundService:
     def __init__(self, db_path):
-        self.path = str(db_path)
-        with self.connect() as conn:
-            store.initialize(conn)
-
-    def connect(self):
-        return store.connect(self.path)
+        self.filename = str(db_path)
+        with journal(self.filename) as connection:
+            connection.execute("CREATE TABLE IF NOT EXISTS event_log(number INTEGER PRIMARY KEY, tag TEXT, owner INTEGER, payload TEXT)")
 
     def create_payment(self, authorized_minor):
         validate_amount(authorized_minor)
-        with self.connect() as conn:
-            return store.insert_payment(conn, authorized_minor)
+        with journal(self.filename) as connection:
+            return append(connection, "approval", None, {"minor": authorized_minor})
 
     def capture(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
-            if payment is None or amount_minor > payment.authorized:
-                raise InvalidAmount("invalid capture")
-            store.set_captured(conn, id, amount_minor)
+        with journal(self.filename) as connection:
+            state = known_state(connection, id)
+            if state["settled"] is not None or amount_minor > state["ceiling"]:
+                raise InvalidAmount("capture not permitted")
+            append(connection, "settlement", id, {"minor": amount_minor})
 
     def refund(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
-            if payment.captured is None:
+        with journal(self.filename) as connection:
+            state = known_state(connection, id)
+            if state["settled"] is None:
                 raise PaymentNotCaptured(id)
-            return store.add_refund(conn, id, amount_minor)
+            if state["returned"] + amount_minor > state["settled"]:
+                raise RefundExceedsCaptured(id)
+            return append(connection, "credit", id, {"minor": amount_minor})
 
     def refunded_total(self, id):
-        with self.connect() as conn:
-            return store.get_payment(conn, id).refunded
+        with journal(self.filename) as connection:
+            return known_state(connection, id)["returned"]

--- starter/refunds\service.py
+++ wrong_checks_single_refund/refunds\service.py
@@ -20,20 +20,22 @@
 
     def capture(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
-            if payment is None or amount_minor > payment.authorized:
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
+            if payment.captured is not None or amount_minor > payment.authorized:
                 raise InvalidAmount("invalid capture")
             store.set_captured(conn, id, amount_minor)
 
     def refund(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
             if payment.captured is None:
                 raise PaymentNotCaptured(id)
+            if amount_minor > payment.captured:
+                raise RefundExceedsCaptured(id)
             return store.add_refund(conn, id, amount_minor)
 
     def refunded_total(self, id):
         with self.connect() as conn:
-            return store.get_payment(conn, id).refunded
+            return store.require_payment(conn, id).refunded
--- starter/refunds\store.py
+++ wrong_checks_single_refund/refunds\store.py
@@ -1,4 +1,5 @@
 """SQLite access for payments and refunds. Each call receives the caller's connection."""
+from contextlib import contextmanager
 import sqlite3
 from dataclasses import dataclass
 
@@ -10,9 +11,29 @@
     captured: int | None
     refunded: int
 
+    @property
+    def refundable(self):
+        """Captured funds not yet refunded; zero before capture."""
+        return 0 if self.captured is None else self.captured - self.refunded
+
 
 def connect(path):
     return sqlite3.connect(str(path), timeout=30)
+
+
+@contextmanager
+def immediate(path):
+    """Write transaction that takes the database write lock up front and always closes its connection."""
+    conn = connect(path)
+    try:
+        conn.execute("BEGIN IMMEDIATE")
+        yield conn
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
 
 
 def initialize(conn):
@@ -30,6 +51,13 @@
     return PaymentRow(*row) if row else None
 
 
+def require_payment(conn, payment_id):
+    payment = get_payment(conn, payment_id)
+    if payment is None:
+        raise ValueError(f"unknown payment {payment_id!r}")
+    return payment
+
+
 def set_captured(conn, payment_id, amount_minor):
     conn.execute("UPDATE payments SET captured=? WHERE id=?", (amount_minor, payment_id))
 

--- starter/refunds\service.py
+++ wrong_counts_rejected/refunds\service.py
@@ -20,20 +20,24 @@
 
     def capture(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
-            if payment is None or amount_minor > payment.authorized:
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
+            if payment.captured is not None or amount_minor > payment.authorized:
                 raise InvalidAmount("invalid capture")
             store.set_captured(conn, id, amount_minor)
 
     def refund(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
             if payment.captured is None:
                 raise PaymentNotCaptured(id)
+            if amount_minor > payment.refundable:
+                conn.execute("UPDATE payments SET refunded=refunded+? WHERE id=?", (amount_minor, id))
+                conn.commit()
+                raise RefundExceedsCaptured(id)
             return store.add_refund(conn, id, amount_minor)
 
     def refunded_total(self, id):
         with self.connect() as conn:
-            return store.get_payment(conn, id).refunded
+            return store.require_payment(conn, id).refunded
--- starter/refunds\store.py
+++ wrong_counts_rejected/refunds\store.py
@@ -1,4 +1,5 @@
 """SQLite access for payments and refunds. Each call receives the caller's connection."""
+from contextlib import contextmanager
 import sqlite3
 from dataclasses import dataclass
 
@@ -10,9 +11,29 @@
     captured: int | None
     refunded: int
 
+    @property
+    def refundable(self):
+        """Captured funds not yet refunded; zero before capture."""
+        return 0 if self.captured is None else self.captured - self.refunded
+
 
 def connect(path):
     return sqlite3.connect(str(path), timeout=30)
+
+
+@contextmanager
+def immediate(path):
+    """Write transaction that takes the database write lock up front and always closes its connection."""
+    conn = connect(path)
+    try:
+        conn.execute("BEGIN IMMEDIATE")
+        yield conn
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
 
 
 def initialize(conn):
@@ -30,6 +51,13 @@
     return PaymentRow(*row) if row else None
 
 
+def require_payment(conn, payment_id):
+    payment = get_payment(conn, payment_id)
+    if payment is None:
+        raise ValueError(f"unknown payment {payment_id!r}")
+    return payment
+
+
 def set_captured(conn, payment_id, amount_minor):
     conn.execute("UPDATE payments SET captured=? WHERE id=?", (amount_minor, payment_id))
 

--- starter/refunds\service.py
+++ wrong_uses_authorized/refunds\service.py
@@ -20,20 +20,22 @@
 
     def capture(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
-            if payment is None or amount_minor > payment.authorized:
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
+            if payment.captured is not None or amount_minor > payment.authorized:
                 raise InvalidAmount("invalid capture")
             store.set_captured(conn, id, amount_minor)
 
     def refund(self, id, amount_minor):
         validate_amount(amount_minor)
-        with self.connect() as conn:
-            payment = store.get_payment(conn, id)
+        with store.immediate(self.path) as conn:
+            payment = store.require_payment(conn, id)
             if payment.captured is None:
                 raise PaymentNotCaptured(id)
+            if amount_minor > payment.authorized - payment.refunded:
+                raise RefundExceedsCaptured(id)
             return store.add_refund(conn, id, amount_minor)
 
     def refunded_total(self, id):
         with self.connect() as conn:
-            return store.get_payment(conn, id).refunded
+            return store.require_payment(conn, id).refunded
--- starter/refunds\store.py
+++ wrong_uses_authorized/refunds\store.py
@@ -1,4 +1,5 @@
 """SQLite access for payments and refunds. Each call receives the caller's connection."""
+from contextlib import contextmanager
 import sqlite3
 from dataclasses import dataclass
 
@@ -10,9 +11,29 @@
     captured: int | None
     refunded: int
 
+    @property
+    def refundable(self):
+        """Captured funds not yet refunded; zero before capture."""
+        return 0 if self.captured is None else self.captured - self.refunded
+
 
 def connect(path):
     return sqlite3.connect(str(path), timeout=30)
+
+
+@contextmanager
+def immediate(path):
+    """Write transaction that takes the database write lock up front and always closes its connection."""
+    conn = connect(path)
+    try:
+        conn.execute("BEGIN IMMEDIATE")
+        yield conn
+        conn.commit()
+    except BaseException:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
 
 
 def initialize(conn):
@@ -30,6 +51,13 @@
     return PaymentRow(*row) if row else None
 
 
+def require_payment(conn, payment_id):
+    payment = get_payment(conn, payment_id)
+    if payment is None:
+        raise ValueError(f"unknown payment {payment_id!r}")
+    return payment
+
+
 def set_captured(conn, payment_id, amount_minor):
     conn.execute("UPDATE payments SET captured=? WHERE id=?", (amount_minor, payment_id))
 

--- starter/fees\schedule.py
+++ reference/fees\schedule.py
@@ -1,10 +1,37 @@
-from fees.models import Tier, Schedule  # noqa: F401
+from fees.models import Tier, Schedule, nonnegative  # noqa: F401
+
+
+def validate_schedule(schedule):
+    tiers = schedule.tiers
+    if not tiers or tiers[-1].up_to_minor is not None:
+        raise ValueError("unbounded last tier required")
+    if not nonnegative(schedule.min_fee_minor) or not nonnegative(schedule.max_fee_minor):
+        raise ValueError("invalid limits")
+    if schedule.min_fee_minor > schedule.max_fee_minor:
+        raise ValueError("invalid clamp interval")
+    prior = -1
+    for tier in tiers[:-1]:
+        if tier.up_to_minor is None or tier.up_to_minor <= prior:
+            raise ValueError("strictly increasing bounded tiers required")
+        prior = tier.up_to_minor
+
+
+def select_tier(amount_minor, schedule):
+    for tier in schedule.tiers:
+        if tier.up_to_minor is None or amount_minor <= tier.up_to_minor:
+            return tier
+    raise ValueError("unbounded tier required")
 
 
 def raw_fee(amount_minor, tier):
-    """Percentage part plus fixed part, in whole minor units."""
-    return amount_minor * tier.bps // 10000 + tier.fixed_minor
+    """Percentage part plus fixed part, rounded half up to a whole minor unit."""
+    numerator = amount_minor * tier.bps + tier.fixed_minor * 10000
+    return (numerator + 5000) // 10000
 
 
 def compute_fee(amount_minor, schedule):
-    return raw_fee(amount_minor, schedule.tiers[0])
+    if type(amount_minor) is not int or amount_minor < 0:
+        raise ValueError("nonnegative integer amount required")
+    validate_schedule(schedule)
+    fee = raw_fee(amount_minor, select_tier(amount_minor, schedule))
+    return min(schedule.max_fee_minor, max(schedule.min_fee_minor, fee))

--- starter/fees\schedule.py
+++ alt_valid/fees\schedule.py
@@ -1,10 +1,29 @@
+from decimal import Decimal, ROUND_HALF_UP, localcontext
 from fees.models import Tier, Schedule  # noqa: F401
 
 
-def raw_fee(amount_minor, tier):
-    """Percentage part plus fixed part, in whole minor units."""
-    return amount_minor * tier.bps // 10000 + tier.fixed_minor
+def check(schedule):
+    bounds = [t.up_to_minor for t in schedule.tiers]
+    if not bounds or bounds[-1] is not None or None in bounds[:-1]:
+        raise ValueError("bounded tiers then one unbounded tier required")
+    bounded = bounds[:-1]
+    if any(later <= earlier for earlier, later in zip(bounded, bounded[1:])):
+        raise ValueError("tier bounds must strictly increase")
+    if not 0 <= schedule.min_fee_minor <= schedule.max_fee_minor:
+        raise ValueError("invalid fee limits")
 
 
 def compute_fee(amount_minor, schedule):
-    return raw_fee(amount_minor, schedule.tiers[0])
+    if not isinstance(amount_minor, int) or isinstance(amount_minor, bool) or amount_minor < 0:
+        raise ValueError("invalid payment amount")
+    check(schedule)
+    selected = next(t for t in schedule.tiers if t.up_to_minor is None or t.up_to_minor >= amount_minor)
+    with localcontext() as ctx:
+        ctx.prec = max(34, len(str(amount_minor)) + len(str(selected.bps)) + 10)
+        raw = Decimal(amount_minor) * Decimal(selected.bps) / Decimal(10000) + selected.fixed_minor
+        fee = int(raw.quantize(Decimal(1), rounding=ROUND_HALF_UP))
+    if fee < schedule.min_fee_minor:
+        return schedule.min_fee_minor
+    if fee > schedule.max_fee_minor:
+        return schedule.max_fee_minor
+    return fee

--- starter/fees\schedule.py
+++ wrong_exclusive_boundary/fees\schedule.py
@@ -1,10 +1,37 @@
-from fees.models import Tier, Schedule  # noqa: F401
+from fees.models import Tier, Schedule, nonnegative  # noqa: F401
+
+
+def validate_schedule(schedule):
+    tiers = schedule.tiers
+    if not tiers or tiers[-1].up_to_minor is not None:
+        raise ValueError("unbounded last tier required")
+    if not nonnegative(schedule.min_fee_minor) or not nonnegative(schedule.max_fee_minor):
+        raise ValueError("invalid limits")
+    if schedule.min_fee_minor > schedule.max_fee_minor:
+        raise ValueError("invalid clamp interval")
+    prior = -1
+    for tier in tiers[:-1]:
+        if tier.up_to_minor is None or tier.up_to_minor <= prior:
+            raise ValueError("strictly increasing bounded tiers required")
+        prior = tier.up_to_minor
+
+
+def select_tier(amount_minor, schedule):
+    for tier in schedule.tiers:
+        if tier.up_to_minor is None or amount_minor < tier.up_to_minor:
+            return tier
+    raise ValueError("unbounded tier required")
 
 
 def raw_fee(amount_minor, tier):
-    """Percentage part plus fixed part, in whole minor units."""
-    return amount_minor * tier.bps // 10000 + tier.fixed_minor
+    """Percentage part plus fixed part, rounded half up to a whole minor unit."""
+    numerator = amount_minor * tier.bps + tier.fixed_minor * 10000
+    return (numerator + 5000) // 10000
 
 
 def compute_fee(amount_minor, schedule):
-    return raw_fee(amount_minor, schedule.tiers[0])
+    if type(amount_minor) is not int or amount_minor < 0:
+        raise ValueError("nonnegative integer amount required")
+    validate_schedule(schedule)
+    fee = raw_fee(amount_minor, select_tier(amount_minor, schedule))
+    return min(schedule.max_fee_minor, max(schedule.min_fee_minor, fee))

--- starter/fees\schedule.py
+++ wrong_float_bps/fees\schedule.py
@@ -1,10 +1,38 @@
-from fees.models import Tier, Schedule  # noqa: F401
+import math
+
+from fees.models import Tier, Schedule, nonnegative  # noqa: F401
+
+
+def validate_schedule(schedule):
+    tiers = schedule.tiers
+    if not tiers or tiers[-1].up_to_minor is not None:
+        raise ValueError("unbounded last tier required")
+    if not nonnegative(schedule.min_fee_minor) or not nonnegative(schedule.max_fee_minor):
+        raise ValueError("invalid limits")
+    if schedule.min_fee_minor > schedule.max_fee_minor:
+        raise ValueError("invalid clamp interval")
+    prior = -1
+    for tier in tiers[:-1]:
+        if tier.up_to_minor is None or tier.up_to_minor <= prior:
+            raise ValueError("strictly increasing bounded tiers required")
+        prior = tier.up_to_minor
+
+
+def select_tier(amount_minor, schedule):
+    for tier in schedule.tiers:
+        if tier.up_to_minor is None or amount_minor <= tier.up_to_minor:
+            return tier
+    raise ValueError("unbounded tier required")
 
 
 def raw_fee(amount_minor, tier):
-    """Percentage part plus fixed part, in whole minor units."""
-    return amount_minor * tier.bps // 10000 + tier.fixed_minor
+    """Percentage part plus fixed part, rounded half up to a whole minor unit."""
+    return math.floor(amount_minor * (tier.bps / 10000) + tier.fixed_minor + .5)
 
 
 def compute_fee(amount_minor, schedule):
-    return raw_fee(amount_minor, schedule.tiers[0])
+    if type(amount_minor) is not int or amount_minor < 0:
+        raise ValueError("nonnegative integer amount required")
+    validate_schedule(schedule)
+    fee = raw_fee(amount_minor, select_tier(amount_minor, schedule))
+    return min(schedule.max_fee_minor, max(schedule.min_fee_minor, fee))

--- starter/fees\schedule.py
+++ wrong_marginal/fees\schedule.py
@@ -1,10 +1,37 @@
-from fees.models import Tier, Schedule  # noqa: F401
+from fees.models import Tier, Schedule, nonnegative  # noqa: F401
 
 
-def raw_fee(amount_minor, tier):
-    """Percentage part plus fixed part, in whole minor units."""
-    return amount_minor * tier.bps // 10000 + tier.fixed_minor
+def validate_schedule(schedule):
+    tiers = schedule.tiers
+    if not tiers or tiers[-1].up_to_minor is not None:
+        raise ValueError("unbounded last tier required")
+    if not nonnegative(schedule.min_fee_minor) or not nonnegative(schedule.max_fee_minor):
+        raise ValueError("invalid limits")
+    if schedule.min_fee_minor > schedule.max_fee_minor:
+        raise ValueError("invalid clamp interval")
+    prior = -1
+    for tier in tiers[:-1]:
+        if tier.up_to_minor is None or tier.up_to_minor <= prior:
+            raise ValueError("strictly increasing bounded tiers required")
+        prior = tier.up_to_minor
+
+
+def marginal_fee(amount_minor, schedule):
+    """Charge each band at its own rate; the fixed fee of the band that contains the amount is added."""
+    total, lower = 0, 0
+    for tier in schedule.tiers:
+        upper = amount_minor if tier.up_to_minor is None else min(amount_minor, tier.up_to_minor)
+        total += max(0, upper - lower) * tier.bps
+        if upper == amount_minor:
+            total += tier.fixed_minor * 10000
+            break
+        lower = upper
+    return (total + 5000) // 10000
 
 
 def compute_fee(amount_minor, schedule):
-    return raw_fee(amount_minor, schedule.tiers[0])
+    if type(amount_minor) is not int or amount_minor < 0:
+        raise ValueError("nonnegative integer amount required")
+    validate_schedule(schedule)
+    fee = marginal_fee(amount_minor, schedule)
+    return min(schedule.max_fee_minor, max(schedule.min_fee_minor, fee))

--- starter/batch\parser.py
+++ reference/batch\parser.py
@@ -3,15 +3,34 @@
 
 
 def parse(data):
-    errors, payments = [], []
-    for line_no, raw in enumerate(physical_lines(data), 1):
-        if raw[:1] != b"D":
+    rows = physical_lines(data)
+    errors, payments, trailers = set(), [], []
+    if not rows or rows[0][:1] != b"H":
+        errors.add((1, "missing_header"))
+    if not rows or rows[-1][:1] != b"T":
+        errors.add((max(1, len(rows)), "missing_trailer"))
+    count = sum(row[:1] == b"D" for row in rows)
+    for line_no, raw in enumerate(rows, 1):
+        kind = raw[:1]
+        if ((kind == b"H" and line_no != 1) or (kind == b"T" and line_no != len(rows))
+                or (kind == b"D" and line_no in {1, len(rows)})):
+            errors.add((line_no, "record_order"))
+        text, local_error = decode(raw)
+        if local_error:
+            errors.add((line_no, local_error))
             continue
-        text, error = decode(raw)
-        if error is None:
-            value, error = fields(text)
-        if error:
-            errors.append(BatchError(line_no, error))
-        else:
+        value, field_error = fields(text)
+        if field_error:
+            errors.add((line_no, field_error))
+        elif text[0] == "D":
             payments.append(value)
-    return BatchResult(not errors, payments, errors)
+        elif text[0] == "T":
+            trailers.append((line_no, value))
+    for line_no, (declared_count, total, hash_total) in trailers:
+        if count == 0 or count != declared_count:
+            errors.add((line_no, "count_mismatch"))
+        if total != sum(p.amount_minor for p in payments):
+            errors.add((line_no, "control_total_mismatch"))
+        if hash_total != sum(int(p.payee_account[-8:]) for p in payments) % 10**10:
+            errors.add((line_no, "hash_total_mismatch"))
+    return BatchResult(not errors, [] if errors else payments, [BatchError(*e) for e in sorted(errors)])
--- starter/batch\records.py
+++ reference/batch\records.py
@@ -1,4 +1,6 @@
 """Fixed-width record decoding shared by offline batch utilities."""
+from datetime import datetime
+import re
 from batch.models import Payment
 
 CURRENCIES = {"CAD", "USD", "EUR", "GBP", "JPY", "KWD", "BHD"}
@@ -21,13 +23,26 @@
 
 
 def fields(text):
-    """Decode the columns of one 80-character record. Only detail records are interpreted so far."""
-    if text[0] == "D":
+    kind = text[0]
+    if kind == "H":
+        valid = bool(re.fullmatch(r"[A-Z0-9]{12}", text[1:13]))
+        try:
+            datetime.strptime(text[13:21], "%Y%m%d")
+            valid = valid and digits(text[13:21])
+        except ValueError:
+            valid = False
+        valid = valid and text[21:24] in CURRENCIES and text[24:] == " " * 56
+        return None, None if valid else "invalid_header"
+    if kind == "D":
         valid = digits(text[1:13]) and digits(text[13:25]) and text[45:] == " " * 35
         if not valid or int(text[13:25]) <= 0 or not text[25:45].strip():
             return None, "invalid_detail"
         return Payment(text[1:13], int(text[13:25]), text[25:45].rstrip(" ")), None
-    return None, None
+    if kind == "T":
+        if not (digits(text[1:7]) and digits(text[7:22]) and digits(text[22:32]) and text[32:] == " " * 48):
+            return None, "invalid_trailer"
+        return (int(text[1:7]), int(text[7:22]), int(text[22:32])), None
+    return None, "record_type"
 
 
 def physical_lines(data):
@@ -36,4 +51,5 @@
     rows = data.split(b"\n")
     if rows[-1] == b"":
         rows.pop()
-    return rows
+    return [row[:-1] if row.endswith(b"\r") and (i < len(rows) - 1 or data.endswith(b"\n")) else row
+            for i, row in enumerate(rows)]

--- starter/batch\parser.py
+++ alt_valid/batch\parser.py
@@ -1,17 +1,44 @@
 from batch.models import BatchResult, Payment, BatchError  # noqa: F401
-from batch.records import decode, fields, physical_lines
+from batch.records import fields, decode, physical_lines
 
 
 def parse(data):
-    errors, payments = [], []
-    for line_no, raw in enumerate(physical_lines(data), 1):
-        if raw[:1] != b"D":
-            continue
-        text, error = decode(raw)
-        if error is None:
-            value, error = fields(text)
-        if error:
-            errors.append(BatchError(line_no, error))
-        else:
-            payments.append(value)
-    return BatchResult(not errors, payments, errors)
+    physical = physical_lines(data)
+    issues = set()
+    details = []
+    number_of_details, amount_sum, account_sum = 0, 0, 0
+    controls = []
+    last_index = len(physical)
+    if not physical or not physical[0].startswith(b"H"):
+        issues.add((1, "missing_header"))
+    if not physical or not physical[-1].startswith(b"T"):
+        issues.add((max(last_index, 1), "missing_trailer"))
+    for index, physical_record in enumerate(physical, start=1):
+        marker = physical_record[:1]
+        if marker == b"D":
+            number_of_details += 1
+        expected_position = {b"H": index == 1, b"T": index == last_index,
+                             b"D": 1 < index < last_index}
+        if marker in expected_position and not expected_position[marker]:
+            issues.add((index, "record_order"))
+        record, issue = decode(physical_record)
+        if issue is None:
+            value, issue = fields(record)
+            if issue is None and marker == b"D":
+                details.append(value)
+                amount_sum += value.amount_minor
+                account_sum = (account_sum + int(value.payee_account[-8:])) % 10**10
+            elif issue is None and marker == b"T":
+                controls.append((index, value))
+        if issue:
+            issues.add((index, issue))
+    for index, declared in controls:
+        observed = number_of_details, amount_sum, account_sum
+        codes = "count_mismatch", "control_total_mismatch", "hash_total_mismatch"
+        for i, code in enumerate(codes):
+            if declared[i] != observed[i] or (i == 0 and number_of_details == 0):
+                issues.add((index, code))
+    ordered_errors = [BatchError(line, code) for line, code in sorted(issues)]
+    if ordered_errors:
+        return BatchResult(False, [], ordered_errors)
+    return BatchResult(True, details, [])
--- starter/batch\records.py
+++ alt_valid/batch\records.py
@@ -1,39 +1,55 @@
-"""Fixed-width record decoding shared by offline batch utilities."""
+"""Pattern-based SBF-80 record decoding (regular expressions instead of column slicing)."""
+from datetime import datetime
+import re
 from batch.models import Payment
 
-CURRENCIES = {"CAD", "USD", "EUR", "GBP", "JPY", "KWD", "BHD"}
+CURRENCY = "CAD|USD|EUR|GBP|JPY|KWD|BHD"
+HEADER = re.compile(rf"H[A-Z0-9]{{12}}([0-9]{{8}})(?:{CURRENCY}) {{56}}")
+DETAIL = re.compile(r"D([0-9]{12})([0-9]{12})([ -~]{20}) {35}")
+TRAILER = re.compile(r"T([0-9]{6})([0-9]{15})([0-9]{10}) {48}")
+PRINTABLE = re.compile(rb"[\x20-\x7e]*")
+LINE_END = re.compile(rb"\r?\n")
 
 
-def digits(text):
-    return bool(text) and all("0" <= char <= "9" for char in text)
+def physical_lines(data):
+    """Split on LF or CRLF terminators; an unterminated final line is kept as it is."""
+    if not data:
+        return []
+    pieces = LINE_END.split(data)
+    if pieces[-1] == b"":
+        pieces.pop()
+    return pieces
 
 
 def decode(raw):
+    if not PRINTABLE.fullmatch(raw):
+        return None, "invalid_encoding"
+    if len(raw) != 80:
+        return None, "line_length"
+    return raw.decode("ascii"), None
+
+
+def header_ok(match):
     try:
-        text = raw.decode("ascii")
-    except UnicodeDecodeError:
-        return None, "invalid_encoding"
-    if any(ord(c) < 32 or ord(c) > 126 for c in text):
-        return None, "invalid_encoding"
-    if len(text) != 80:
-        return None, "line_length"
-    return text, None
+        datetime.strptime(match.group(1), "%Y%m%d")
+    except ValueError:
+        return False
+    return True
 
 
 def fields(text):
-    """Decode the columns of one 80-character record. Only detail records are interpreted so far."""
-    if text[0] == "D":
-        valid = digits(text[1:13]) and digits(text[13:25]) and text[45:] == " " * 35
-        if not valid or int(text[13:25]) <= 0 or not text[25:45].strip():
+    kind = text[0]
+    if kind == "H":
+        match = HEADER.fullmatch(text)
+        return None, None if match and header_ok(match) else "invalid_header"
+    if kind == "D":
+        match = DETAIL.fullmatch(text)
+        if not match or int(match.group(2)) <= 0 or not match.group(3).strip():
             return None, "invalid_detail"
-        return Payment(text[1:13], int(text[13:25]), text[25:45].rstrip(" ")), None
-    return None, None
-
-
-def physical_lines(data):
-    if not data:
-        return []
-    rows = data.split(b"\n")
-    if rows[-1] == b"":
-        rows.pop()
-    return rows
+        return Payment(match.group(1), int(match.group(2)), match.group(3).rstrip(" ")), None
+    if kind == "T":
+        match = TRAILER.fullmatch(text)
+        if not match:
+            return None, "invalid_trailer"
+        return tuple(int(group) for group in match.groups()), None
+    return None, "record_type"

--- starter/batch\parser.py
+++ wrong_crlf_slicing/batch\parser.py
@@ -3,15 +3,34 @@
 
 
 def parse(data):
-    errors, payments = [], []
-    for line_no, raw in enumerate(physical_lines(data), 1):
-        if raw[:1] != b"D":
+    rows = physical_lines(data)
+    errors, payments, trailers = set(), [], []
+    if not rows or rows[0][:1] != b"H":
+        errors.add((1, "missing_header"))
+    if not rows or rows[-1][:1] != b"T":
+        errors.add((max(1, len(rows)), "missing_trailer"))
+    count = sum(row[:1] == b"D" for row in rows)
+    for line_no, raw in enumerate(rows, 1):
+        kind = raw[:1]
+        if ((kind == b"H" and line_no != 1) or (kind == b"T" and line_no != len(rows))
+                or (kind == b"D" and line_no in {1, len(rows)})):
+            errors.add((line_no, "record_order"))
+        text, local_error = decode(raw)
+        if local_error:
+            errors.add((line_no, local_error))
             continue
-        text, error = decode(raw)
-        if error is None:
-            value, error = fields(text)
-        if error:
-            errors.append(BatchError(line_no, error))
-        else:
+        value, field_error = fields(text)
+        if field_error:
+            errors.add((line_no, field_error))
+        elif text[0] == "D":
             payments.append(value)
-    return BatchResult(not errors, payments, errors)
+        elif text[0] == "T":
+            trailers.append((line_no, value))
+    for line_no, (declared_count, total, hash_total) in trailers:
+        if count == 0 or count != declared_count:
+            errors.add((line_no, "count_mismatch"))
+        if total != sum(p.amount_minor for p in payments):
+            errors.add((line_no, "control_total_mismatch"))
+        if hash_total != sum(int(p.payee_account[-8:]) for p in payments) % 10**10:
+            errors.add((line_no, "hash_total_mismatch"))
+    return BatchResult(not errors, [] if errors else payments, [BatchError(*e) for e in sorted(errors)])
--- starter/batch\records.py
+++ wrong_crlf_slicing/batch\records.py
@@ -1,4 +1,6 @@
 """Fixed-width record decoding shared by offline batch utilities."""
+from datetime import datetime
+import re
 from batch.models import Payment
 
 CURRENCIES = {"CAD", "USD", "EUR", "GBP", "JPY", "KWD", "BHD"}
@@ -21,13 +23,26 @@
 
 
 def fields(text):
-    """Decode the columns of one 80-character record. Only detail records are interpreted so far."""
-    if text[0] == "D":
+    kind = text[0]
+    if kind == "H":
+        valid = bool(re.fullmatch(r"[A-Z0-9]{12}", text[1:13]))
+        try:
+            datetime.strptime(text[13:21], "%Y%m%d")
+            valid = valid and digits(text[13:21])
+        except ValueError:
+            valid = False
+        valid = valid and text[21:24] in CURRENCIES and text[24:] == " " * 56
+        return None, None if valid else "invalid_header"
+    if kind == "D":
         valid = digits(text[1:13]) and digits(text[13:25]) and text[45:] == " " * 35
         if not valid or int(text[13:25]) <= 0 or not text[25:45].strip():
             return None, "invalid_detail"
         return Payment(text[1:13], int(text[13:25]), text[25:45].rstrip(" ")), None
-    return None, None
+    if kind == "T":
+        if not (digits(text[1:7]) and digits(text[7:22]) and digits(text[22:32]) and text[32:] == " " * 48):
+            return None, "invalid_trailer"
+        return (int(text[1:7]), int(text[7:22]), int(text[22:32])), None
+    return None, "record_type"
 
 
 def physical_lines(data):

--- starter/batch\parser.py
+++ wrong_ignores_hash_total/batch\parser.py
@@ -3,15 +3,32 @@
 
 
 def parse(data):
-    errors, payments = [], []
-    for line_no, raw in enumerate(physical_lines(data), 1):
-        if raw[:1] != b"D":
+    rows = physical_lines(data)
+    errors, payments, trailers = set(), [], []
+    if not rows or rows[0][:1] != b"H":
+        errors.add((1, "missing_header"))
+    if not rows or rows[-1][:1] != b"T":
+        errors.add((max(1, len(rows)), "missing_trailer"))
+    count = sum(row[:1] == b"D" for row in rows)
+    for line_no, raw in enumerate(rows, 1):
+        kind = raw[:1]
+        if ((kind == b"H" and line_no != 1) or (kind == b"T" and line_no != len(rows))
+                or (kind == b"D" and line_no in {1, len(rows)})):
+            errors.add((line_no, "record_order"))
+        text, local_error = decode(raw)
+        if local_error:
+            errors.add((line_no, local_error))
             continue
-        text, error = decode(raw)
-        if error is None:
-            value, error = fields(text)
-        if error:
-            errors.append(BatchError(line_no, error))
-        else:
+        value, field_error = fields(text)
+        if field_error:
+            errors.add((line_no, field_error))
+        elif text[0] == "D":
             payments.append(value)
-    return BatchResult(not errors, payments, errors)
+        elif text[0] == "T":
+            trailers.append((line_no, value))
+    for line_no, (declared_count, total, hash_total) in trailers:
+        if count == 0 or count != declared_count:
+            errors.add((line_no, "count_mismatch"))
+        if total != sum(p.amount_minor for p in payments):
+            errors.add((line_no, "control_total_mismatch"))
+    return BatchResult(not errors, [] if errors else payments, [BatchError(*e) for e in sorted(errors)])
--- starter/batch\records.py
+++ wrong_ignores_hash_total/batch\records.py
@@ -1,4 +1,6 @@
 """Fixed-width record decoding shared by offline batch utilities."""
+from datetime import datetime
+import re
 from batch.models import Payment
 
 CURRENCIES = {"CAD", "USD", "EUR", "GBP", "JPY", "KWD", "BHD"}
@@ -21,13 +23,26 @@
 
 
 def fields(text):
-    """Decode the columns of one 80-character record. Only detail records are interpreted so far."""
-    if text[0] == "D":
+    kind = text[0]
+    if kind == "H":
+        valid = bool(re.fullmatch(r"[A-Z0-9]{12}", text[1:13]))
+        try:
+            datetime.strptime(text[13:21], "%Y%m%d")
+            valid = valid and digits(text[13:21])
+        except ValueError:
+            valid = False
+        valid = valid and text[21:24] in CURRENCIES and text[24:] == " " * 56
+        return None, None if valid else "invalid_header"
+    if kind == "D":
         valid = digits(text[1:13]) and digits(text[13:25]) and text[45:] == " " * 35
         if not valid or int(text[13:25]) <= 0 or not text[25:45].strip():
             return None, "invalid_detail"
         return Payment(text[1:13], int(text[13:25]), text[25:45].rstrip(" ")), None
-    return None, None
+    if kind == "T":
+        if not (digits(text[1:7]) and digits(text[7:22]) and digits(text[22:32]) and text[32:] == " " * 48):
+            return None, "invalid_trailer"
+        return (int(text[1:7]), int(text[7:22]), int(text[22:32])), None
+    return None, "record_type"
 
 
 def physical_lines(data):
@@ -36,4 +51,5 @@
     rows = data.split(b"\n")
     if rows[-1] == b"":
         rows.pop()
-    return rows
+    return [row[:-1] if row.endswith(b"\r") and (i < len(rows) - 1 or data.endswith(b"\n")) else row
+            for i, row in enumerate(rows)]

--- starter/batch\parser.py
+++ wrong_partial_accept/batch\parser.py
@@ -3,15 +3,36 @@
 
 
 def parse(data):
-    errors, payments = [], []
-    for line_no, raw in enumerate(physical_lines(data), 1):
-        if raw[:1] != b"D":
+    rows = physical_lines(data)
+    errors, payments, trailers = set(), [], []
+    if not rows or rows[0][:1] != b"H":
+        errors.add((1, "missing_header"))
+    if not rows or rows[-1][:1] != b"T":
+        errors.add((max(1, len(rows)), "missing_trailer"))
+    count = sum(row[:1] == b"D" for row in rows)
+    for line_no, raw in enumerate(rows, 1):
+        kind = raw[:1]
+        if ((kind == b"H" and line_no != 1) or (kind == b"T" and line_no != len(rows))
+                or (kind == b"D" and line_no in {1, len(rows)})):
+            errors.add((line_no, "record_order"))
+        text, local_error = decode(raw)
+        if local_error:
+            errors.add((line_no, local_error))
             continue
-        text, error = decode(raw)
-        if error is None:
-            value, error = fields(text)
-        if error:
-            errors.append(BatchError(line_no, error))
-        else:
+        value, field_error = fields(text)
+        if field_error:
+            errors.add((line_no, field_error))
+        elif text[0] == "D":
             payments.append(value)
-    return BatchResult(not errors, payments, errors)
+        elif text[0] == "T":
+            trailers.append((line_no, value))
+    for line_no, (declared_count, total, hash_total) in trailers:
+        if count == 0 or count != declared_count:
+            errors.add((line_no, "count_mismatch"))
+        if total != sum(p.amount_minor for p in payments):
+            errors.add((line_no, "control_total_mismatch"))
+        if hash_total != sum(int(p.payee_account[-8:]) for p in payments) % 10**10:
+            errors.add((line_no, "hash_total_mismatch"))
+    if payments and any(code == "invalid_detail" for _, code in errors):
+        return BatchResult(True, payments, [BatchError(*e) for e in sorted(errors)])
+    return BatchResult(not errors, [] if errors else payments, [BatchError(*e) for e in sorted(errors)])
--- starter/batch\records.py
+++ wrong_partial_accept/batch\records.py
@@ -1,4 +1,6 @@
 """Fixed-width record decoding shared by offline batch utilities."""
+from datetime import datetime
+import re
 from batch.models import Payment
 
 CURRENCIES = {"CAD", "USD", "EUR", "GBP", "JPY", "KWD", "BHD"}
@@ -21,13 +23,26 @@
 
 
 def fields(text):
-    """Decode the columns of one 80-character record. Only detail records are interpreted so far."""
-    if text[0] == "D":
+    kind = text[0]
+    if kind == "H":
+        valid = bool(re.fullmatch(r"[A-Z0-9]{12}", text[1:13]))
+        try:
+            datetime.strptime(text[13:21], "%Y%m%d")
+            valid = valid and digits(text[13:21])
+        except ValueError:
+            valid = False
+        valid = valid and text[21:24] in CURRENCIES and text[24:] == " " * 56
+        return None, None if valid else "invalid_header"
+    if kind == "D":
         valid = digits(text[1:13]) and digits(text[13:25]) and text[45:] == " " * 35
         if not valid or int(text[13:25]) <= 0 or not text[25:45].strip():
             return None, "invalid_detail"
         return Payment(text[1:13], int(text[13:25]), text[25:45].rstrip(" ")), None
-    return None, None
+    if kind == "T":
+        if not (digits(text[1:7]) and digits(text[7:22]) and digits(text[22:32]) and text[32:] == " " * 48):
+            return None, "invalid_trailer"
+        return (int(text[1:7]), int(text[7:22]), int(text[22:32])), None
+    return None, "record_type"
 
 
 def physical_lines(data):
@@ -36,4 +51,5 @@
     rows = data.split(b"\n")
     if rows[-1] == b"":
         rows.pop()
-    return rows
+    return [row[:-1] if row.endswith(b"\r") and (i < len(rows) - 1 or data.endswith(b"\n")) else row
+            for i, row in enumerate(rows)]