Why a Smart Contract?
A smart contract is a program that runs on a blockchain. Once deployed, no one can change its behavior — not TimeProof, not Polygon, not anyone. It executes exactly as written, every time.
This matters because trust is the whole point. If your timestamps were stored in TimeProof’s database, you’d have to trust that:
- We didn’t backdate entries
- We didn’t modify records
- We’ll still be around to verify them in 10 years
With a smart contract on a public blockchain, you don’t have to trust anyone. The math enforces the rules.
How the TimeProofAnchor Contract Works
The TimeProofAnchor smart contract is deliberately simple — simple code has fewer bugs and is easier to audit. Here’s what it does:
1. Hash Submission
When you timestamp a file, your browser computes the SHA-256 hash locally. This hash is sent to TimeProof’s backend, which submits it to the smart contract.
For Instant timestamps, the hash (or a small batch Merkle root) is submitted immediately.
For Scheduled timestamps, hashes are collected over a window and combined into a Merkle tree. The Merkle root — a single hash representing the entire batch — is then submitted to the contract.
2. Immutable Recording
The smart contract records:
- The submitted hash (or Merkle root)
- The block timestamp (set by the Polygon network, not by TimeProof)
- The transaction sender (TimeProof’s anchoring address)
Once a block is confirmed, this data is permanent. Polygon’s proof-of-stake consensus with Ethereum checkpoints means the record is secured by two blockchains.
3. Public Verification
Anyone, anywhere, at any time can:
- Look up the transaction on Polygonscan
- See the anchored hash in the transaction data
- Verify the block timestamp
- Confirm the sender address matches TimeProof’s known anchoring wallet
No account needed. No API key. No permission from TimeProof. The blockchain is public.
The Merkle Tree Architecture
When you timestamp 200 files with Scheduled timestamps, TimeProof doesn’t write 200 transactions to the blockchain. That would be wasteful and expensive. Instead, it uses a Merkle tree.
How it works
- Each file’s SHA-256 hash becomes a leaf in the tree
- Adjacent leaves are paired and hashed together to create parent nodes
- This process repeats until a single Merkle root remains
- Only the root is written to the blockchain — one transaction for potentially thousands of files
Why this is secure
Your file’s inclusion in the batch is provable via a Merkle proof — a small set of hashes that, when combined with your file’s hash following the tree structure, reproduces the Merkle root.
If anyone changes even one bit of one file in the batch, the Merkle root changes completely. The proof is tamper-evident by construction.
What you receive
With Legal-Grade, your evidence bundle includes merkle_proof.json — the exact path through the tree that proves your file was included in the anchor. Any developer (or expert witness) can independently verify this proof.
Verification Paths
TimeProof provides multiple independent verification paths, so you’re never dependent on a single point of failure:
Path 1: TimeProof Verification Page
Upload your file → we recalculate the hash → match against blockchain records → show you the timestamp details.
Depends on: TimeProof being operational.
Path 2: Manual Polygonscan Lookup
Take the transaction ID from your certificate → paste it into Polygonscan → see the anchored data directly on the blockchain.
Depends on: Polygon network and Polygonscan being operational. Even if Polygonscan goes down, any Polygon node operator can verify the data.
Path 3: JWS Identity Verification
Take the identity_attestation.jws from your Legal-Grade bundle → verify the signature against TimeProof’s public key at /.well-known/jwks.json.
Depends on: The JWS standard (RFC 7515) and a public key. Even if TimeProof is gone, the cached public key can verify the signature.
Path 4: Full Independent Verification
With the complete Legal-Grade evidence bundle, a technically competent party can:
- Hash the original file with SHA-256
- Verify the Merkle proof against the on-chain Merkle root
- Verify the JWS against the public key
- Confirm the blockchain timestamp on any Polygon node
Depends on: Only the Polygon blockchain existing (secured by Ethereum checkpoints).
Why Polygon?
TimeProof chose Polygon after evaluating multiple blockchain options:
| Factor | Polygon | Ethereum L1 | Bitcoin | Solana |
|---|---|---|---|---|
| Transaction cost | Under $0.01 | $2-50+ | $1-30+ | Under $0.01 |
| Confirmation time | 2-3 sec | 12-15 sec | ~10 min | ~0.4 sec |
| Security model | PoS + ETH checkpoints | PoS | PoW | PoH + PoS |
| Environmental impact | Low | Low | High | Low |
| Ecosystem maturity | High | Highest | Highest | Medium |
| EVM compatible | Yes | Yes | No | No |
Polygon offers the best balance of low cost (enabling gasless timestamps), fast confirmations (essential for Instant timestamps), strong security (Ethereum checkpoint backing), and ecosystem maturity (well-established tools, explorers, and developer support).
What “Gasless” Actually Means
When you timestamp a file, you don’t pay any blockchain transaction fee. TimeProof pays the Polygon gas fee on your behalf. This is possible because:
- Polygon gas costs are extremely low — typically fractions of a cent per transaction
- Merkle batching means one transaction can cover hundreds of files
- Your credit purchase covers both TimeProof’s service and the gas costs
The result: you never need MATIC tokens, a blockchain wallet, or any cryptocurrency knowledge. TimeProof abstracts the entire blockchain layer away.
Contract Transparency
The TimeProofAnchor smart contract code is:
- Open source — published and verified on Polygonscan
- Auditable — anyone can read the Solidity source code
- Immutable — once deployed, the contract logic cannot be changed
- Verifiable — every transaction is public and searchable
This is the fundamental difference between TimeProof and proprietary timestamp services. We don’t ask you to trust our database. We ask you to verify our blockchain.