An account can leave active validator storage entirely, keep nothing but a single hash on-chain, and still be proven and restored - bit for bit.
Walk the full lifecycle below: create state, compress it off the ledger, verify it still exists with a Merkle proof, then decompress it back. The proof check runs real SHA-256 in your browser, so you do not have to trust this page.
Every validator on Thru keeps the current state of active accounts so it can check the next transaction. State only grows, and storing all of it forever is the expensive part of running a chain.
Compression breaks that link. A compressed account is archived off the active ledger - validators drop its data and keep only its commitment inside one global Merkle tree. The root of that tree is the single value the whole network agrees on. To touch the account again, you decompress it by handing back its data together with a proof that it was compressed in exactly that state.
The account did not vanish. Its truth moved into a hash. Everything below is that idea, made touchable.
Step through a single account as it moves in and out of active state. The panel on the left is its live state and updates at every step.
You connect the embedded Thru wallet, approve with a passkey, and the program creates a permanent account with a creation proof. The signer, the fee payer and the managed account can all be different keys - the wallet handles that separation for you.
Give it something to say, then create it.
tsys_account_create() + TN_STATE_PROOF_TYPE_CREATIONRewrite the message. Each write bumps the sequence and produces a new data hash, and the transaction reports exactly what it cost - compute, memory and state units come straight off the RPC, not from a marketing slide.
tsys_account_resize() + set_account_data_writable()Now remove the account from active state. Its data is hashed into a single Merkle leaf, validators stop storing the bytes, and only the leaf commitment remains under the global state root. Storage flips from validator to off-chain.
You keep the original data yourself. That is the trade: the chain stops paying to store it, and in exchange you hold the bytes you will need to bring it back.
tsys_account_compress() -> emits capsule_compressedThe bytes are gone from every validator, yet the account is still real. An EXISTING proof is a path of sibling hashes from your account's leaf up to the state root. Rebuild that path, and if the top matches the root the network published, the account provably existed in this exact state.
The check below runs in your browser with the Web Crypto SHA-256. Nothing is sent anywhere. Flip the tamper switch to watch a single changed bit break the proof.
Send the data and the proof in one transaction. The program checks the proof against the state root, restores the account to active storage, and every field returns unchanged - same address, same owner, same sequence, same data hash.
tsys_account_decompress() + TN_STATE_PROOF_TYPE_EXISTINGBuilding this touches nearly every layer Thru ships, which is the point - it is a working read of the platform, not a faucet tap.
The program is plain C compiled to RISC-V. No chain-specific language, close to the metal, aimed at high-compute and high-write workloads.
Permanent and ephemeral accounts, sequence, flags, and creation, existing and updating state proofs.
Embedded wallet with passkey approval and a separate signing context, so signer and fee payer need not be the managed account.
A published ABI with instruction, account and event roots lets the explorer decode every capsule transaction on sight.