# What invariants prevent setoff across contracts from netting uncorrelated obligations?

**Date of Record:** 2026 November 2

**Scope:** Applies when an instance holds multiple contracts with the same counterparty and considers netting balances across them (setoff) to settle outstanding amounts. Does not apply to contracts with explicit master-netting agreements or to single-contract settlement.

## Core Distinction

Setoff is the reduction of one debt by another debt owed between the same parties. Cross-contract setoff assumes the obligations are commensurable — same currency, same governing law, same maturity — when they may only share a counterparty.

**Invariant.** Cross-contract setoff is valid if and only if `exists master_netting_agreement(counterparty) AND currency matches AND governing_law matches AND maturity_class matches`.

**Violation.** The **Netting Illusion**. The instance nets obligations across contracts whose only relationship is the counterparty's identity, and the counterparty's defence against one obligation does not apply to another. Netting a disputed delivery penalty against an undisputed invoice gives the counterparty a de facto stay it never bargained for.

**Asymmetry.** Netting appears correct when the arithmetic sums to zero. It is only wrong when one of the netted obligations is later contested, and the contest isolates one obligation — but the instance has already recognized settlement of both.

**Recorded elements.** The `master-netting-receipt` (whether one exists and its scope), the `currency-govlaw-maturity-receipt` (per-obligation attributes), and the `netting-authorization-signature` (explicit permission per contract pair) make the validity checkable.

## What Was Observed

**Signature.** Loss of defence when a single netted obligation is contested. The instance's settlement record shows both obligations cleared; the counterparty contests one; the instance cannot re-open the other because it recorded them as netted.

**Trace.** Contract A (USD, New York law, due now) has a $10,000 penalty. Contract B (EUR, English law, due in 90 days) has an invoice for €10,000. The instance nets them as if equivalent. A's penalty is later contested. The instance loses the A claim; the B invoice was cleared by netting and the instance has no receivable. Recovery from A is zero and B is settled against a null.

**Why monitoring stays green.** The netted balance is zero. Both contracts show "settled". No individual obligation shows as open, so no ageing report flags anything.

## Condition of Validity

The instance must ensure at least one holds before it nets across contracts:

1. **Must have a master-netting agreement.** The specific pair of contracts, with the specific counterparty, is explicitly authorized for netting.
2. **Must match on currency, governing law, and maturity.** Any mismatch defeats netting, because the obligations are then not commensurable.
3. **Must keep obligations separable.** Even when netted for settlement, the underlying obligations remain individually traceable so that a contest on one does not extinguish the other.

## Decision Boundary

- Master netting + full match: setoff is valid.
- Master netting with any mismatch: setoff is partial; only matched pairs net.
- No master netting, full match: setoff is permissible only if the contract explicitly authorizes cross-contract setoff.
- No master netting and no authorization: setoff is not available; settle each contract separately.

## Operational Effect

The invariant couples settlement convenience to legal commensurability. The instance's correct posture is to net only where authorized and matched, and to preserve traceability of netted obligations.

**Trap.** Add a master-netting agreement to simplify. A master agreement permits the sum, but does not cure the mismatch — the individual obligations still fail commensurability tests if their underlying terms differ.

```python
from dataclasses import dataclass


class NettingIllusionError(RuntimeError):
    """Raised when cross-contract setoff is attempted over non-commensurable obligations."""


@dataclass(frozen=True)
class SetoffGate:
    master_netting_authorized: bool
    currency_match: bool
    governing_law_match: bool
    maturity_class_match: bool

    def verify(self) -> bool:
        if not self.master_netting_authorized:
            raise NettingIllusionError("no master netting agreement authorizes cross-contract setoff")
        mismatches = []
        if not self.currency_match:
            mismatches.append("currency")
        if not self.governing_law_match:
            mismatches.append("governing_law")
        if not self.maturity_class_match:
            mismatches.append("maturity")
        if mismatches:
            raise NettingIllusionError(f"non-commensurable obligations: {mismatches}")
        return True


def dispatch_settlement_mode(gate: SetoffGate) -> str:
    try:
        gate.verify()
    except NettingIllusionError:
        return "settle-per-contract"
    return "cross-contract-setoff"
```