Skip to main content
Order-Time Determinism (OTD) is the first of Intention’s four protocol-native guarantees. It is the base property the other three rest on.

​
Definition

Let N1N_1 and N2N_2 be two honest nodes starting from identical pre-state Σ\Sigma, executing the same committed block B=(t0,…,tn−1)B = (t_0, \ldots, t_{n-1}) whose quorum certificate is valid. Let the execution result on each node be (Σ′,E,O)(\Sigma', E, O) — the post-state, the ordered event stream, and the per-transaction output array. OTD requires:
  • Σ1′=Σ2′\Sigma'_1 = \Sigma'_2
  • E1=E2E_1 = E_2
  • O1=O2O_1 = O_2
where equality is byte-level equality of the serialized representations. Moreover, the matching priority of any order within BB depends only on the order’s position in the canonical transaction order of BB. It does not depend on wall-clock time, network delivery order, or any other extra-protocol signal.

​
Why it matters

OTD is the protocol-level enforcement of price-time priority — the rule that has organized order-book markets for more than two centuries. On a general-purpose chain, price-time priority is an application-layer promise subject to block-producer reordering. A trader cannot independently verify, from the chain’s own data, that their order was matched in the position their arrival time should have given them. Under OTD, an observer that knows the pre-state and the committed block can independently reconstruct the exact sequence of fills, events, and state changes, byte for byte. The observer does not need to trust anyone — not the validators, not the indexer, not the exchange operator. Matching priority stops being a claim and becomes a property. OTD is also the base property that makes the other guarantees coherent. PTA requires an unambiguous “the transaction that consults the price” — which is only well-defined if the transaction order is itself unambiguous. PTAD requires the per-transaction output array to be a pure function of input — which is only true if execution is deterministic.

​
How Intention enforces it

OTD is a joint property of consensus and execution. At the consensus layer, the Canonical Sequencing Commitment promotes the transaction order within a block to a first-class consensus-committed object. The block hash covers the ordered payload after batch resolution, so any reordering after consensus would invalidate the existing signatures. 2f+12f+1 stake-weighted signatures on the block already constitute a commitment to the specific ordering. At the execution layer, IntentionKernel runs transactions sequentially over the canonical order and enforces a strict byte-determinism discipline:
  • No hash-randomized iteration. Sorted (B-tree) containers are used in place of hash containers throughout the execution path, even where the latter would be faster for per-key operations. Hash-randomized iteration would produce different output orderings on different validators.
  • No floating-point arithmetic. Floating-point may differ across CPU architectures, compilers, and rounding-mode defaults. All quantities are fixed-point integers in protocol-defined scales.
  • No system-time reads. The only time reference used by execution is the block timestamp, which is itself a consensus-committed field.
  • No runtime entropy. No calls to random-number generators in the execution path. Any randomness required by the protocol is computed deterministically from chain state.
  • Canonical serialization. A strictly defined format with no optional fields, no implementation-defined ordering, and no variable-length padding.
Byte-determinism is enforced, not assumed. Intention maintains a differential testing harness that replays committed blocks against two independent engine instantiations and compares write sets and event streams byte for byte. A divergence is a build-breaking, consensus-breaking bug.
The chain of reasoning that closes OTD: the block is committed by 2f+12f+1 signatures over a specific transaction ordering (CSC); sequential execution over that ordering produces a byte-deterministic result; therefore any two honest nodes starting from the same pre-state and executing the same committed block produce byte-identical outputs.

​
What this enables

  • Independent verification of matching priority. Anyone with the pre-state and the committed block can reproduce the exact fills. No indexer is in the trust path.
  • Consensus without re-execution ambiguity. Validators agree on state roots because they agree on every byte of the state, not because they agree on an equivalent serialization.
  • A base for the other guarantees. PTA binds a specific price to a specific ordered transaction list. PTAD produces a per-transaction output array that is a pure function of (Σ,B)(\Sigma, B). Both require OTD to hold.
  • Block-granularity price-time priority. Since “time” inside a block is the canonical intra-block position committed by consensus, no sub-millisecond colocation advantage applies within a block. Combined with the priority schedule that runs cancellations before aggressive placements, this is a structural defense against same-block sniping.
OTD is strictly a property of execution against a finalized block. It does not constrain which transactions enter a block — that is the domain of leader discretion, mitigated separately by reputation and venue-diversity requirements in IntentionBFT.