TVP
Temporal Value Protocol
schedule Built on TPS & OpenLogs

Value lives
in time.

TVP resolves currencies, metals, tax rules, crypto, and contract values against a verifiable temporal coordinate. Every result is a replayable value event with declared source, policy, and proof — not just a number. 

{{ heroUri }}
{{ m.value }} {{ m.label }}
crisis_alert The problem

Static values break in real systems.

Exchange rates move, tax rules change, contract windows expire, and settlement often happens later than intent. A value record without exact timing and explicit rules cannot be audited or replayed safely.

{{ c.icon }}

{{ c.title }}

{{ c.body }}

schema Core model

Value = asset + amount + unit + time + source + policy + proof

TVP stays one protocol family. Domain resolution happens inside the value namespace — v.fx, v.gold, or v.tax — while TPS remains the time foundation beneath it. 

{{ grammar }}
label {{ key.name }} = {{ key.meaning }}
account_tree Ecosystem position
{{ step.icon }}
{{ step.title }}
{{ step.body }}
{{ step.note }}
verified Core principles

Hard rules, not suggestions.

If the protocol gets fuzzy about time, source, or policy, it collapses back into a pricing helper. Strong invariants from the start.

{{ i + 1 }}

{{ p.title }}

{{ p.body }}

data_object Examples

One grammar, many value domains.

Keep the protocol surface narrow and let domain resolvers interpret it. One parser, one proof model, one explain mode.

{{ ex.icon }} {{ ex.label }} 
{{ ex.uri }}

{{ ex.body }}

description Resolver contract

Deterministic by design.

The same normalized input must produce the same output when given the same snapshot and policy version. That keeps TVP replayable and auditable.

code_blocks

Request & response shape

{{ responseExample }}
conversion_path

Resolver pipeline

{{ i + 1 }}
{{ s.title }}
{{ s.body }}
{{ s.note }}
checklist Developer checklist

Build order that keeps the protocol strong.

Launch narrow. Parser, normalization, static sources, FX and metals resolvers, proof foundation, and explain mode are enough for v0.1.

{{ item.number }}
{{ item.icon }} {{ item.phase }}

{{ item.title }}

  • {{ pt }}
package_2 Package map

Small core, pluggable domains.

{{ pkg.name }} {{ pkg.body }}
{{ pkg.stage }}
hub Published dependencies

Consume the existing standards, don't fork them.

Treat TPS parsing and normalization as external, versioned dependencies. Treat OpenLogs as the default audit path for proofs, hashes, signatures, and replay evidence. 

{{ installBlock }}
  • Use TPS raw plus normalized forms in stored records.
  • Emit proof events to OpenLogs when proof mode is enabled.
  • Keep TVP domain adapters separate from the proof transport layer.
help FAQ

Questions the spec should answer directly.

Decisions most likely to cause ambiguity if left implicit. Put them in the core spec, not in implementation folklore.

{{ f.question }}

{{ f.answer }}

If TPS tells you when something is true, TVP tells you what it was worth at that truth.