<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Janzeer blog</title>
    <link>https://janzeer.org/blog</link>
    <atom:link href="https://janzeer.org/blog/feed.xml" rel="self" type="application/rss+xml" />
    <description>Articles about the Janzeer network: how it works, how to build on it, and what we learned running it.</description>
    <language>en</language>
    <lastBuildDate>Mon, 16 Nov 2026 12:00:00 +0000</lastBuildDate>
    <item>
      <title>Non-custodial by design: how Janzeer keys are made, and why the address is not an Ethereum address</title>
      <link>https://janzeer.org/blog/non-custodial-by-design</link>
      <guid isPermaLink="true">https://janzeer.org/blog/non-custodial-by-design</guid>
      <pubDate>Mon, 16 Nov 2026 12:00:00 +0000</pubDate>
      <description>Sixth article of the series. Where your keys live, how twelve words become an address, and why a Janzeer address that looks like an Ethereum address is not one.</description>
      <category>Blockchain</category>
      <category>Cryptography</category>
      <category>Wallets</category>
      <category>Security</category>
      <content:encoded><![CDATA[<p><a href="https://janzeer.org/blog/one-native-binary">The last article</a> was about the people who run the network. This one is about the people who use it, and the one rule that shapes every tool they touch: the keys never leave the user's device.</p>
<h2>The rule</h2>
<p>Janzeer is non-custodial everywhere. In practice that means:</p>
<ul>
<li><strong>The node never sees a private key.</strong> Its API can read balances, nonces and transactions, and it accepts transactions that are already signed. There is no endpoint that creates a key, stores one or signs for you.</li>
<li><strong>Every wallet signs locally.</strong> The mobile and desktop wallet, the web wallet in the explorer, the wallet inside Telegram and the <code>jz</code> command-line client all derive keys and sign on the device, then send only the signed bytes.</li>
<li><strong>Services built on top follow the same rule.</strong> The <a href="https://t.me/janzeerwallet_bot" target="_blank" rel="noopener">Telegram tip bot</a> that went live this week never holds a coin: it prepares a payment, your own wallet signs it, and the bot confirms it only after reading it on the chain.</li>
</ul>
<p>The cost is the usual one: if you lose your recovery words, nobody can restore your account. The benefit is that there is no place where everyone's keys sit together waiting to be stolen.</p>
<h2>From twelve words to a key</h2>
<p>A new wallet starts with a recovery phrase of 12 or 24 words from the standard BIP39 word list. The words are the only thing you need to back up; everything else is computed from them, the same way on every device.</p>
<p>The steps:</p>
<ol>
<li><strong>Words to seed.</strong> The phrase is stretched into a 64-byte seed with PBKDF2-HMAC-SHA512 and 2,048 rounds. An optional passphrase can be added, which turns the same words into a completely different wallet.</li>
<li><strong>Seed to master key.</strong> An HMAC-SHA512 of the seed gives a master private key and a chain code.</li>
<li><strong>Master key to account key.</strong> The wallet derives the key at path <code>m/0/0/0</code> on the secp256k1 curve, the same curve Bitcoin and Ethereum use.</li>
</ol>
<p>Two of these steps use the string <code>@_Janzeer_Blockchain_@</code> where the BIP39 and BIP32 standards use <code>mnemonic</code> and <code>Bitcoin seed</code>. That is deliberate: a Janzeer phrase typed into another chain's wallet produces unrelated keys, and the reverse is true too. A recovery phrase belongs to one network, which removes a whole class of mix-ups.</p>
<h2>From key to address</h2>
<p>The address is the first 20 bytes of the Keccak-256 hash of the 33-byte compressed public key, written as <code>0x</code> and 40 hex characters.</p>
<p>It looks exactly like an Ethereum address, and that is the trap. Ethereum hashes the 64-byte uncompressed key and takes the last 20 bytes. So the same private key gives one address on Ethereum and a different one on Janzeer. An Ethereum wallet, library or exchange that "supports addresses like this" will compute the wrong address and sign the wrong bytes. Janzeer is not EVM-compatible and does not pretend to be.</p>
<p>Mixed-case addresses work the way Ethereum's checksum does: the case of each letter encodes a check, so a typo in a mixed-case address is caught before sending. The network itself stores addresses in lower case and accepts both forms.</p>
<h2>What a signature covers</h2>
<p>A transaction is signed over its exact bytes: the network id, a timestamp, the fee, the sender's nonce, the sender's address and the transfer itself (amount, recipient, memo). The signature is a deterministic ECDSA signature with a canonical low-S value, so the same transaction always signs to the same bytes, and nobody can produce a second valid variant of it.</p>
<p>Two details protect users without their noticing:</p>
<ul>
<li><strong>The network id is part of what is signed.</strong> A transaction signed for the test network cannot be replayed on mainnet, or the other way round.</li>
<li><strong>The nonce is part of what is signed.</strong> Each transaction from an account carries the next number in sequence, so a signed transaction can be applied once and never again.</li>
</ul>
<h2>Five SDKs, one set of answers</h2>
<p>Re-implementing cryptography in five languages is how small chains lose money: one SDK rounds an amount differently, or hashes one byte more, and its signatures fail, or worse. The Janzeer node's code is the single source of truth, and a shared file of test vectors records the expected output of every step for fixed inputs: seed, keys, address, checksum, every transaction type's bytes, hash and signature.</p>
<p>The <a href="https://janzeer.org/docs" target="_blank" rel="noopener">TypeScript, Dart, Kotlin, Python and Go SDKs</a> and every wallet must reproduce that file byte for byte before a release. You can check one yourself: the test phrase <code>abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about</code> must give the address <code>0x06e1c0fa9955a700876f8cb0acc7f13fba9fb8ba</code> in every one of them. Never send coins to it; everyone knows its key.</p>
<h2>Keeping the words safe on a device</h2>
<p>The wallets store the recovery phrase encrypted, never in plain text: the password is stretched with PBKDF2-SHA256 over 250,000 rounds and the phrase is sealed with AES-256-GCM. The encrypted format is shared by the SDKs and <code>jz</code>, so a wallet file exported from one of them opens in another with the same password.</p>
<p>The habits that matter most are not cryptographic: write the words on paper, keep them off cloud notes and screenshots, and never type them into a website that asks for them. No Janzeer service will ever ask for your recovery phrase.</p>
<p>Today the chain is past block 250,000 with seven validators. Next: five SDKs and one conformance kit, or how the test vectors above keep five languages in step.</p>
<hr>
<p><em>Janzeer is built with AI assistance (Claude Code); every number here is from the <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">live chain</a> and the <a href="https://janzeer.org/docs" target="_blank" rel="noopener">public documentation</a>, and the text is mine. JNZ is the network's unit, it is not listed anywhere, and nothing in this series is financial advice.</em></p>]]></content:encoded>
    </item>
    <item>
      <title>One native binary: a Layer-1 node on a 2 GB VPS and a Raspberry Pi 3</title>
      <link>https://janzeer.org/blog/one-native-binary</link>
      <guid isPermaLink="true">https://janzeer.org/blog/one-native-binary</guid>
      <pubDate>Sun, 15 Nov 2026 12:00:00 +0000</pubDate>
      <description>Fifth article of the series. What it takes to run a Janzeer validator, why the node ships as a single native binary, and what the smallest machines taught us about it.</description>
      <category>Blockchain</category>
      <category>GraalVM</category>
      <category>Raspberry Pi</category>
      <category>Self Hosting</category>
      <content:encoded><![CDATA[<p><a href="https://janzeer.org/blog/one-block-finality">The last article</a> explained why a Janzeer block is final once five of the seven validators have committed it. That raises the practical question: what does it take to be one of those seven?</p>
<p>The answer we aimed for from the start: a machine you already have. Not a rack, not a cloud account with a monthly bill in three digits, not a staked fortune. Today five validators run together on one rented 2 GB server, and two run on single-board computers in people's homes, one of them a Raspberry Pi 3 from 2016.</p>
<h2>One file, no runtime</h2>
<p>The node is written in Kotlin on Spring Boot: a peer-to-peer layer, the consensus engine, a database, a REST and JSON-RPC API, and the block explorer's web pages. A normal Java service like that needs a Java runtime and starts in tens of seconds.</p>
<p>Janzeer ships it as a GraalVM native image instead. The whole node is compiled ahead of time into one executable file of about 250 MB. There is nothing else to install: no Java, no database server (it brings an embedded database, or uses PostgreSQL if you have one), no container runtime. On the 2 GB server it starts in about 3 seconds; on the Pi 3 in about 30.</p>
<p>The <a href="https://janzeer.org/validators" target="_blank" rel="noopener">download page</a> has the same node for Linux x64, Linux arm64 (Raspberry Pi and other boards), Windows, an Arch Linux package and a Docker image. Every release carries a <code>SHA256SUMS</code> file signed with the project's key, so you can check that what you downloaded is what was released before you run it.</p>
<h2>What running one looks like</h2>
<ol>
<li>Download the bundle for your machine and verify the signature.</li>
<li>Unpack it and run <code>./start.sh</code>. The node creates its own identity, connects to the network and synchronises the chain from block one, checking every block itself.</li>
<li>When it reports <code>SYNCHRONIZED</code>, it is a full watch-only node: it follows and verifies the chain, and its API answers your wallet or your scripts.</li>
<li>To validate, open the P2P port and send one registration transaction with a one-time 2,000 JNZ deposit, as described in <a href="https://janzeer.org/blog/why-no-staking">the article about validators</a>. The node joins the set at the next epoch boundary, about three days later.</li>
</ol>
<p>The bundle also contains <code>update.sh</code>, which checks for a newer signed release and installs it, and <code>jz</code>, the command-line client, so <code>./jz node status</code> tells you how the node is doing.</p>
<h2>Why the binary matters on small machines</h2>
<p>Memory decides what fits. A Java process grows its heap towards a share of the machine's physical memory unless you stop it; five of them next to a database would not fit in 2 GB. The native image starts small, its heap is capped at 256 MB, and its code pages are shared between processes. On the server, five validator nodes, PostgreSQL, the explorer, a Telegram game and a mail server share 2 GB. Before we rented that server, we proved it on a desktop by running the same binaries inside a memory cage of the same size for six hours.</p>
<p>The Pi 3 has 1 GB, of which 905 MB are usable. A synced node sits at about 370 MB there. That leaves room, but not much, and the board found every place where the node used memory carelessly.</p>
<h2>What the smallest machine taught the node</h2>
<p>Running on a 1 GB board turned up problems that a big server hides:</p>
<ul>
<li><strong>A cleanup step loaded 287 MB of staged blocks into a 256 MB heap</strong> when a sync was restarted. On the server nobody noticed; on the Pi the sync thread died. The cleanup now deletes in the database without loading anything.</li>
<li><strong>Temporary files went to <code>/tmp</code></strong>, which on Raspberry Pi OS lives in RAM. A bulk database statement wrote 405 MB there. The node now keeps its temporary files on its own disk.</li>
<li><strong>An unclean stop costs a long check at the next boot</strong>, because the node re-validates its last two epochs when it cannot prove it was stopped cleanly. On the server that took 2.5 minutes, on the Pi 22. The node now writes a marker on every clean shutdown and skips the check when the marker matches.</li>
</ul>
<p>Every one of these became a fix in the node, released for everyone, not a special Pi build. The full story, with the numbers, is in <a href="https://janzeer.org/blog/raspberry-pi-3-mainnet-validator">the Raspberry Pi article</a>.</p>
<h2>What the operator learns</h2>
<p>Some lessons have nothing to do with code. Use a proper power supply: an under-powered Pi drops its Wi-Fi without a word, and a validator that is silent for hours loses its seat. A board without a real-time clock boots with the wrong time after a power cut, and a node does not produce blocks until its clock is correct, because slots are assigned by time. And restart a validator right after its own block, not in the middle of its turn.</p>
<p>The server side has its own story: <a href="https://janzeer.org/blog/bft-chain-on-a-2gb-vps">running the whole network on one 2 GB VPS</a>, what broke in the seven-day acceptance test before launch, and how upgrades now restart the validators one by one so that no block is missed.</p>
<h2>Why it is worth it</h2>
<p>A network whose validators need a data centre ends up run by data centres. A network whose validators run on a Pi in a living room can be run by anyone who cares to. Today the chain is at block 248,850, with seven validators. The <a href="https://janzeer.org/validators#grant" target="_blank" rel="noopener">grant programme</a> pays the 2,000 JNZ deposit for the first ten outside operators, and the first application arrived this week.</p>
<p>Next: non-custodial by design, or how keys are derived and why a Janzeer address is not an Ethereum address.</p>
<hr>
<p><em>Janzeer is built with AI assistance (Claude Code); every number here is from the <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">live chain</a> and the project's own release notes and incident reports, and the text is mine. JNZ is the network's unit, it is not listed anywhere, and nothing in this series is financial advice.</em></p>]]></content:encoded>
    </item>
    <item>
      <title>Final in one block: 15-second slots and the two-phase BFT vote</title>
      <link>https://janzeer.org/blog/one-block-finality</link>
      <guid isPermaLink="true">https://janzeer.org/blog/one-block-finality</guid>
      <pubDate>Sat, 14 Nov 2026 12:00:00 +0000</pubDate>
      <description>Fourth article of the series. What happens inside one 15-second slot, why a block is final once it is committed, and what the network does when too many validators are silent.</description>
      <category>Blockchain</category>
      <category>Consensus</category>
      <category>Byzantine Fault Tolerance</category>
      <category>Finality</category>
      <content:encoded><![CDATA[<p><a href="https://janzeer.org/blog/first-token-on-mainnet">The last article</a> took a detour through the first token on mainnet. Back to the protocol. This one is about the question an exchange or a shop asks first: when is a payment really done?</p>
<p>On many chains the answer is a number of confirmations. You wait for six blocks, or twelve, or thirty, because a block can still be replaced by a longer competing chain. On Janzeer the answer is one block. Once a transaction is in a committed block, it is final. There are no confirmation counts and no reorganisations. Here is how that works, and what it costs.</p>
<h2>Time is cut into slots</h2>
<p>Every 15 seconds is one slot: a 12-second window to produce and vote, then a 3-second pause. Each slot has exactly one owner, a validator chosen round-robin from the active set. Every node works out the owner from the wall clock and the start time of the current epoch, so nobody has to announce whose turn it is.</p>
<p>That is also why clocks matter. A node whose clock drifts more than 250 milliseconds from NTP time stops producing blocks. It keeps following the chain, but it does not take its turn until its clock is right again.</p>
<p>If the owner of a slot is offline, the slot passes empty and the next owner continues. A validator that misses its slots is removed from the set at the next epoch boundary, and it can come back later.</p>
<h2>Two rounds of votes</h2>
<p>The slot owner builds a block from pending transactions and sends it to the other validators. Then two rounds of voting follow:</p>
<ol>
<li><strong>PREPARE.</strong> Each validator checks the block and signs a PREPARE vote for it.</li>
<li><strong>COMMIT.</strong> When a validator has seen enough PREPARE votes, it re-executes every transaction in the block, checks the resulting state against the block's merkle roots, and signs a COMMIT vote.</li>
</ol>
<p>"Enough" is a quorum: more than two thirds of the active validators. With N validators the quorum is ⌊2N/3⌋ + 1. Today there are <a href="https://explorer.janzeer.org/validators" target="_blank" rel="noopener">seven validators</a>, so the quorum is five. When five COMMIT votes exist, the block is final, and every node adds it to its chain.</p>
<p>Votes are signed messages, and at first every validator sends every vote to every other one. When a round reaches its quorum, the votes are bundled into one quorum certificate and that single message is passed on. This keeps traffic small on home connections and Raspberry Pis.</p>
<h2>Why one block is enough</h2>
<p>Two facts make a committed block permanent.</p>
<p>First, any two quorums overlap. Five of seven and another five of seven always share at least three validators. For two different blocks to be committed at the same height, those shared validators would have had to vote for both of them.</p>
<p>Second, voting twice is provable. A validator may cast one vote per slot per round. If it signs two different votes for the same slot, both signed messages together are a proof, and anyone can submit that proof to the chain. A validator proven twice is banned for good, and the reporter receives 5 JNZ from the treasury.</p>
<p>So a second block at the same height would need at least three validators to cheat, and each of them would leave signed evidence. With seven validators the network tolerates two faulty or malicious ones. The general rule is f faulty validators out of 3f + 1.</p>
<p>On top of that, every node that adds a block re-executes it. A node does not trust the producer, the votes, or the peer it syncs from. If a block's state does not match what the transactions produce, the node refuses the block.</p>
<h2>The price: when too many are silent, the chain stops</h2>
<p>The same rule works the other way. If fewer than five of the seven validators are online and voting, no block reaches a quorum, and no block is produced. The chain does not split into two histories; it waits. When enough validators return, block production resumes from the last final block.</p>
<p>This is a deliberate choice of safety over liveness. A payment can be delayed, but it can never be undone. It is also not theoretical. In late October the network stopped twice for about four hours: once because too many validators were offline at the same time, and once because of a bug in how votes were counted for a slot. Both are described, with the fixes, in the <a href="https://janzeer.org/incidents" target="_blank" rel="noopener">incident reports</a> and in a longer post-mortem on <a href="https://dev.to/syriandeveloper/three-ways-a-bft-chain-goes-quiet-a-week-of-incidents-on-a-small-layer-1-315k" target="_blank" rel="noopener">dev.to</a>. The lesson was not to weaken the quorum. It was to add more independent validators and to make silent failures visible. A fifth project validator was added the same week.</p>
<h2>What it means if you build on it</h2>
<p>For anyone who accepts JNZ, the rules are short:</p>
<ul>
<li>Credit a transaction when its status is <code>FINAL</code> and its receipt is successful. Never credit a <code>PENDING</code> one.</li>
<li>There is nothing more to wait for. A committed block is not rolled back.</li>
<li><code>janzeer_waitForFinality</code> in the JSON-RPC API waits for exactly that moment. Each of the five SDKs wraps it in one call.</li>
</ul>
<p>The <a href="https://janzeer.org/docs/pdf/en/integration-guide.pdf" target="_blank" rel="noopener">integration guide</a> has the full checklist for an exchange or a payment service.</p>
<p>In numbers, as of today: block 247,358, epoch 15, seven validators, one new block every 15 seconds. Everything in this article can be checked against the <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">live explorer</a>.</p>
<p>Next: one native binary, and what it takes to run a Layer-1 node on a 2 GB VPS and on a Raspberry Pi 3.</p>
<hr>
<p><em>Janzeer is built with AI assistance (Claude Code); every number here is from the <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">live chain</a> and the protocol facts in the <a href="https://janzeer.org/docs" target="_blank" rel="noopener">public documentation</a>, and the text is mine. JNZ is the network's unit, it is not listed anywhere, and nothing in this series is financial advice.</em></p>]]></content:encoded>
    </item>
    <item>
      <title>The first token: one transaction type, five operations, and an afternoon on mainnet</title>
      <link>https://janzeer.org/blog/first-token-on-mainnet</link>
      <guid isPermaLink="true">https://janzeer.org/blog/first-token-on-mainnet</guid>
      <pubDate>Sat, 14 Nov 2026 12:00:00 +0000</pubDate>
      <description>Third article of the series. How tokens work on Janzeer, and what happened when the first real one was created on 9 November 2026.</description>
      <category>Blockchain</category>
      <category>Tokens</category>
      <category>Python</category>
      <category>TypeScript</category>
      <content:encoded><![CDATA[<p><a href="https://janzeer.org/blog/why-no-staking">Yesterday</a> was about validators. Today is a detour I did not plan, because something happened on the chain on 9 November that is worth telling while it is fresh: the first token was created on Janzeer mainnet, and every rule the token system has was exercised in one afternoon.</p>
<h2>What a token is here</h2>
<p>Most chains get tokens from smart contracts: a program holds a table of balances, and "sending a token" means calling that program. Janzeer has no virtual machine, on purpose. Tokens are a native feature of the ledger, specified as one transaction type with an operation byte, called JZT-1. The five operations are <strong>create</strong>, <strong>mint</strong>, <strong>burn</strong>, <strong>set cap</strong> and <strong>transfer</strong>.</p>
<p>A token has a symbol, a name, a number of display decimals, a maximum supply (the cap) and an issuer. Its identity is the hash of the transaction that created it, so there is no registry to squat and no name to fight over; two tokens may share a symbol, and the id tells them apart. Every token is its own ledger: minting a billion units of something changes nothing about the fixed 100,000,000 JNZ supply, the treasury or the block rewards. Fees for token operations are paid in JNZ like any other fee.</p>
<p>Three rules give the system its shape:</p>
<ol>
<li><strong>Only a registered validator's wallet can create a token.</strong> The fee is an exact 5 JNZ. This is a spam gate, not a privilege: anyone who runs a node and pays the 2,000 JNZ deposit described <a href="https://janzeer.org/blog/why-no-staking">yesterday</a> may issue tokens. An ordinary wallet that tries is refused at submission, before a block is wasted.</li>
<li><strong>Only the issuer can mint, burn or change the cap</strong>, and the ledger enforces two invariants on every path, live or during sync: the supply can never exceed the cap, and the cap can never drop below the minted supply.</li>
<li><strong>Anyone can hold and send a token.</strong> A transfer costs the normal minimum fee of 0.01 JNZ and is final in one block like a JNZ transfer.</li>
</ol>
<h2>What happened on 9 November</h2>
<p>I had never created a token on mainnet; the feature had only run in the automated integration test and on the local developer network. So I did it the way a user would, from the web wallet inside the explorer, using the wallet that registered one of my validators.</p>
<p>The result is called <strong>DEMO</strong>, "Janzeer Demo Token", two decimals, a cap of one million, an initial supply of one hundred thousand. <a href="https://explorer.janzeer.org/tokens/a125c23c403f992c36a472050e5709a43b359dda6bc9113e2bc39050ba8a19c6" target="_blank" rel="noopener">Its page on the explorer</a> shows everything below.</p>
<p>Then I ran through the operations in an order chosen to hit the rules:</p>
<ul>
<li>Sent 1,000 DEMO to a second wallet. Transfers from the <a href="https://github.com/janzeerOrg/janzeer-sdk-python" target="_blank" rel="noopener">Python SDK</a> and the <a href="https://github.com/janzeerOrg/janzeer-sdk-ts" target="_blank" rel="noopener">TypeScript SDK</a> moved some of it on to two more addresses, final in blocks 221,511 and 221,514.</li>
<li>Minted 100,000. Supply 150,000.</li>
<li>Burned 50,000. Supply back to 100,000.</li>
<li>Tried to set the cap to 100,000 while the supply stood above it. <strong>Refused</strong>: "cap below the minted supply". No fee, because the node rejects it at the door.</li>
<li>Set the cap to 200,000. Accepted.</li>
<li>Tried to mint 60,000, which would have pushed the supply past the new cap. <strong>Refused</strong>.</li>
<li>Minted 50,000. Supply 200,000, exactly at the cap.</li>
</ul>
<p>Every acceptance and every refusal matched the specification. The explorer's token page lists the holders and the operations in order, and the SDKs read the same numbers through REST and JSON-RPC. The whole run is recorded in the project's test guide.</p>
<h2>What it cost and what it is worth</h2>
<p>Creating the token cost 5 JNZ. The six accepted operations cost 0.01 JNZ each. The two refusals cost nothing.</p>
<p>DEMO itself is worth nothing, and I want to be plain about that. It exists so that the feature has a real example that anyone can look at, send, and build against. It is not for sale, it will not be listed anywhere, and if someone offers you DEMO for money they are not from this project.</p>
<h2>What I learned from the wallet</h2>
<p>Doing it as a user found two rough edges in the web wallet within minutes, which the test suite could never have shown me. After each operation the Tokens panel kept showing the old balances until I reloaded the page, because the wallet never re-read the chain after a submit, and a transaction lands one or two slots after it is accepted. And the assets list had no way to copy a token id. Both are fixed: the wallet now re-reads the chain every few seconds until the committed state changes, shows a small "waiting for the next block" line while it does, and every asset row has a copy button. They ship with the next node release, since the explorer is built into the node binary.</p>
<p>The mobile wallet, which had tokens switched off since launch, got them back in <a href="https://github.com/janzeerOrg/janzeer-wallet/releases/tag/v1.2.8" target="_blank" rel="noopener">version 1.2.8</a> the same evening: a Tokens tab that shows what you hold, a send page with paste, scan and a review step, and receive at your usual address. The issuer operations are one level deeper, behind an "Issuer tools" link, because most people will only ever send and receive.</p>
<h2>Try it</h2>
<p>The DEMO token is on the explorer, and if you hold a few JNZ for fees any of the five SDKs, the <code>jz</code> command-line client or the wallet can send it. A transfer is about twenty lines in Python:</p>
<pre><code class="language-python">from janzeer import Account, JanzeerClient, JanzeerRpc, TxBuilder, wait_for_finality
import os

NODE = &quot;https://explorer.janzeer.org&quot;
TOKEN = &quot;a125c23c403f992c36a472050e5709a43b359dda6bc9113e2bc39050ba8a19c6&quot;   # DEMO
client, rpc = JanzeerClient(NODE), JanzeerRpc(NODE)
me = Account.from_mnemonic(os.environ[&quot;MNEMONIC&quot;])

tx = me.sign_tx(TxBuilder.token.transfer(
    sender=me.address, token_id=TOKEN, amount=2500,          # 25.00 DEMO, in base units
    recipient=&quot;0x598b1301acef3baba6ce25e38dd17b723f7b98b1&quot;,
    nonce=client.nonce(me.address), network_id=client.info()[&quot;networkId&quot;]))
client.submit(tx)
final = wait_for_finality(rpc, tx.hash)
print(&quot;final in block&quot;, final[&quot;blockHeight&quot;])
</code></pre>
<p>That script, recorded live, is the <a href="https://www.youtube.com/@janzeerorg" target="_blank" rel="noopener">one-minute token video</a>. The token section of the <a href="https://janzeer.org/docs" target="_blank" rel="noopener">developer guide</a> has the byte layout and every rule.</p>
<p>Tomorrow we return to the plan: what happens inside those fifteen seconds, and why a committed block is final.</p>
<p><em>Janzeer is built with AI assistance (Claude Code); every number here is from the <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">live chain</a>, and the text is mine. JNZ is the network's unit, it is not listed anywhere, DEMO has no value, and nothing in this series is financial advice.</em></p>]]></content:encoded>
    </item>
    <item>
      <title>Why no staking: validators, the 2,000 JNZ deposit and rotating seats</title>
      <link>https://janzeer.org/blog/why-no-staking</link>
      <guid isPermaLink="true">https://janzeer.org/blog/why-no-staking</guid>
      <pubDate>Tue, 10 Nov 2026 12:00:00 +0000</pubDate>
      <description>Second article of the series. How a Janzeer validator gets in, what the deposit buys, how seats are assigned, and how the launch nodes work themselves out of power.</description>
      <category>Blockchain</category>
      <category>Consensus</category>
      <category>Validators</category>
      <content:encoded><![CDATA[<p><a href="https://janzeer.org/blog/what-is-janzeer">Yesterday's article</a> gave the shape of Janzeer: a block every 15 seconds, final in one block, a fixed supply, no staking. Today is about the part people ask about first. If nobody stakes, who validates, why would they, and what stops a thousand fake nodes from taking over?</p>
<h2>What a stake does, and what it costs</h2>
<p>Proof-of-stake solves one problem well: it makes identities expensive. A validator must lock coins, so an attacker needs a large share of the coins to hold a large share of the votes. The side effects are the part I do not like.</p>
<p>The lock earns yield, so validating becomes an investment product. Weight follows wealth: whoever holds the most coins casts the most votes and earns the most new coins. Smaller holders delegate to pools, and a few pools end up casting most votes on most chains. Unbonding periods, slashing of the stake, and reward-sharing contracts pile on top, and each one is a place where things go wrong.</p>
<p>Janzeer keeps the useful part, expensive identities, and drops the rest. A validator identity costs 2,000 JNZ, once, and that payment buys exactly one seat with exactly one vote. It earns nothing by itself.</p>
<h2>Getting in: one transaction</h2>
<p>A validator is a node plus one registration transaction. The node syncs the chain, then its operator sends a registration carrying the node's public key, a fixed fee of 3 JNZ, and a deposit of 2,000 JNZ. There is no application, no vote, no approval by anyone. If the transaction is valid, the node is registered.</p>
<p>The deposit goes to the <a href="https://janzeer.org/transparency" target="_blank" rel="noopener">treasury</a>, the key-less address that pays block rewards, and it never comes back. Not when the validator leaves, not when the network grows, not on request. That is the whole Sybil guard: a thousand fake validators cost two million JNZ, paid into the pot that rewards the honest ones. I will say plainly that this guard is softer than a large stake or proof-of-work. It is sized for a small network of operators who run nodes because they want to run nodes.</p>
<p>A registered node joins the validator set at the next epoch boundary. The <a href="https://explorer.janzeer.org/validators" target="_blank" rel="noopener">explorer's validators page</a> shows it as pending until then.</p>
<h2>Seats, epochs and rotation</h2>
<p>Time on Janzeer is divided into epochs of 17,000 blocks, about three days. At each boundary every node computes the same new validator set from the chain's state, and a special genesis block records it. From then until the next boundary the set is frozen: slot after slot, the right to propose a block goes round the set in a fixed order, and the set votes.</p>
<p>The set has at most 21 seats. While fewer validators are registered, everyone who is registered and awake has a seat. When more register than there are seats, the longest-registered validators keep their seats and five of the seats rotate, epoch by epoch, through a standby bench of up to a hundred, in registration order. No lottery, no weight, no bidding: the order you joined is the order you serve.</p>
<p>Two things remove a validator from the set. If it stays silent on its assigned slots for an epoch, it is dropped at the next boundary; it keeps its registration and comes back when its node is healthy. And a validator can leave on purpose with an exit transaction, which takes it out of the schedule at the next boundary instead of degrading the chain for three days. Either way the deposit is gone.</p>
<h2>What the validator earns</h2>
<p>Every block pays its producer 10 JNZ from the treasury, plus 80 percent of the fees in that block. The other 20 percent of fees returns to the treasury. Nothing is shared with anyone, nothing is claimed later, nothing is paid for merely being registered. Rewards are for work, measured one block at a time.</p>
<p>The reward halves roughly every year, and the treasury is finite. In the long run a validator lives on fees, which is how it should be on a chain with a fixed supply.</p>
<p>With seven validators today, each produces one block in seven, about 820 blocks a day. That is the current arithmetic, not a forecast; it changes with every validator that joins, and JNZ has no price to multiply it by.</p>
<h2>Misbehaviour</h2>
<p>The one thing a validator can do to hurt the chain, besides being offline, is to vote twice in the same slot for two different blocks. Every node keeps one vote per validator per slot per voting stage. A second, conflicting vote is itself the proof: any node that sees it wraps it into a slashing transaction, and the chain records the offense. After two proven offenses the key is banned permanently. Whoever reported it receives a 5 JNZ bounty from the treasury.</p>
<p>There is no slashing of a stake because there is no stake. The penalty is the seat and the 2,000 JNZ that bought it.</p>
<h2>The launch problem: anchors that phase themselves out</h2>
<p>Every new chain faces the same awkward moment: at block one there is nobody to validate but its creator. Janzeer launched with three anchor nodes run by the project, and they are privileged in exactly one way: an anchor cannot be dropped for downtime. The number of privileged anchors is written into every epoch's genesis block, so any node can reconstruct it.</p>
<p>That privilege is designed to expire. Once enough independent validators have proven themselves, meaning they produced blocks in each of the last two epochs, one anchor loses its privilege per epoch. A demoted anchor is not switched off; it keeps validating like any other registrant and can be dropped like any other registrant. The rule never lets the healthy set fall below four, and if the independent set collapses later, dormant anchors re-engage. The anchors are scaffolding, and the chain takes the scaffolding down on its own schedule.</p>
<p>Today the project still runs five of the seven validators: the anchors and a fifth node. The other two are a Raspberry Pi 3 in my home and a balenaFin board at a friend's. I want that ratio to turn around, and the mechanism to turn it around is already live.</p>
<h2>If you want a seat</h2>
<p>Running a validator takes a machine with 2 GB of memory and a public port, the node bundle from the <a href="https://janzeer.org/validators" target="_blank" rel="noopener">validators page</a>, and the 2,003 JNZ for the registration. For the first ten outside operators the project covers that amount through a <a href="https://github.com/janzeerorg/janzeer-node/issues/new?template=validator-grant.yml" target="_blank" rel="noopener">grant</a>, paid from the ecosystem wallet to the address you name, until the first of January 2027 at the latest. One grant per operator, and the project's own nodes do not count. The <a href="https://janzeer.org/docs" target="_blank" rel="noopener">operator guide</a> walks through the whole thing; a <a href="https://janzeer.org/raspberry-pi" target="_blank" rel="noopener">Raspberry Pi has done it</a>, so a small VPS will.</p>
<p>Tomorrow: what happens inside those 15 seconds. The two-phase vote, why a committed block is final, and what the chain does when a validator is missing.</p>
<p><em>Janzeer is built with AI assistance (Claude Code); every number here is from the <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">live chain</a> and the protocol facts in the <a href="https://janzeer.org/docs" target="_blank" rel="noopener">public documentation</a>, and the text is mine. JNZ is the network's unit, it is not listed anywhere, and nothing in this series is financial advice.</em></p>]]></content:encoded>
    </item>
    <item>
      <title>What is Janzeer? A Layer-1 with no staking, explained in ten minutes</title>
      <link>https://janzeer.org/blog/what-is-janzeer</link>
      <guid isPermaLink="true">https://janzeer.org/blog/what-is-janzeer</guid>
      <pubDate>Mon, 09 Nov 2026 12:00:00 +0000</pubDate>
      <description>Mainnet since 1 October 2026, seven validators, finality in one block. What it is, what it is not, and how it was built.</description>
      <category>Blockchain</category>
      <category>Layer 1</category>
      <category>Consensus</category>
      <category>Open Source</category>
      <content:encoded><![CDATA[<p>I run a small public blockchain called Janzeer. It has been producing a block every fifteen seconds since the first of October, it is on <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">block 221,000</a> and counting, and seven validators keep it alive, two of them single-board computers in people's homes. This is the first article of a series. Today only the shape of the thing; the next pieces go one layer deeper each day: validators, consensus, running a node, wallets, the SDKs, the money, the incidents, and how it was built.</p>
<h2>Why another chain</h2>
<p>Two things about proof-of-stake never sat right with me.</p>
<p>The first is the capital gate. On most chains the right to validate is bought with a stake, and the stake earns yield, so the people with the most coins validate the most and earn the most. Delegation makes it worse: a handful of pools end up voting for everyone. The second is the operations burden. Running a validator on the large chains means a serious server, a sync that takes days, and a slashing risk if your box goes offline during a storm.</p>
<p>I wanted a chain where joining as a validator costs a one-time fee and nothing else, where a seat is a seat regardless of how rich its owner is, and where the node is one file you can run on a Raspberry Pi. And I wanted transactions to be final the moment they are in a block, without "wait for twelve confirmations".</p>
<p>Janzeer is that attempt. It is not a fork of anything; the node is written from scratch in Kotlin.</p>
<h2>The shape, in six facts</h2>
<p><strong>A block every 15 seconds, final in one block.</strong> Time is cut into 15-second slots. Each slot belongs to one validator, who proposes a block. The others vote in two rounds, prepare and commit. When more than two thirds agree in the commit round, the block is final. There are no confirmations to count and no reorganisations to wait out. If the owner of a slot is offline, the slot is empty and the next one proceeds.</p>
<p><strong>Validators register, they do not stake.</strong> Anyone can become a validator by sending one transaction with a 2,000 JNZ deposit. The deposit goes to the treasury and is not returned, ever, even when the validator leaves. It buys a seat and nothing more: no yield on the deposit, no voting weight, no delegation. Every seat has the same weight. Seats are assigned per epoch of 17,000 blocks, roughly three days, and rotate when there are more registered validators than seats. The cap is 21 seats.</p>
<p><strong>A fixed supply that existed on day one.</strong> There are 100,000,000 JNZ and there will never be more. All of it was created in the genesis block: 77.5 million in a key-less treasury address that pays block rewards, 12 million in an ecosystem pool, 7.5 million for the founder, and 1 million for each of the three anchor nodes that bootstrapped the network. Nothing is minted later. The block reward is 10 JNZ, paid out of the treasury to the block producer, and it halves roughly every year. Twenty percent of every fee flows back to the treasury. When the treasury is empty, rewards are fees only.</p>
<p><strong>Non-custodial everywhere.</strong> The node never sees a private key. Wallets derive keys on the device, sign locally, and send signed transactions. This holds for the mobile wallet, the web wallet in the explorer, the command-line client and every SDK.</p>
<p><strong>One native binary.</strong> The node is a GraalVM native image, about 260 MB, with no Java runtime to install. The whole mainnet bootstrap, four validators plus PostgreSQL plus a Telegram game, runs on one virtual server with 2 GB of memory and one core. A Raspberry Pi 3 with 1 GB has been a validator since October.</p>
<p><strong>Everything is documented in English and Arabic.</strong> The <a href="https://janzeer.org/docs" target="_blank" rel="noopener">white paper, the developer guide, the API reference</a>, the wallet, and every announcement exist in both languages. Arabic is not a translation added later; it is a first-class language of the project.</p>
<h2>Where it stands today</h2>
<p>Numbers from the explorer on 9 November 2026, 40 days after launch:</p>
<ul>
<li>Block 221,056, fourteenth epoch, average block time 15.0 seconds.</li>
<li>7 active validators: five run by the project (four on the launch server plus a fifth node), one Raspberry Pi 3 in my home, one balenaFin board at a friend's.</li>
<li>Node version 0.1.11, eleven releases since launch, upgrades roll one validator at a time without a missed block.</li>
<li>Two incidents, both in late October, both published with their causes on the <a href="https://janzeer.org/incidents" target="_blank" rel="noopener">incidents page</a>: the chain stood still for about four hours each time while every node was convinced it was synchronised. The fixes shipped within a day each. I will write that story in full later in this series.</li>
<li>About a quarter of the supply is outside the treasury; the rest sits in the treasury address, which has no key.</li>
</ul>
<p>It is small. I would rather say so than let anyone expect a network the size of the ones they know.</p>
<h2>What it is not</h2>
<p>JNZ is the unit of the network: fees, deposits and rewards are counted in it. It is not listed on any exchange, it has no price, and nothing in this series is financial advice or a promise of either. There is no token sale, no airdrop campaign, no "join now before it is too late". If you want JNZ today, the ways are to run a validator and earn block rewards, to play the <a href="https://t.me/jpong_bot/jpong" target="_blank" rel="noopener">Telegram game</a> that pays its winners from a finite budget, or to have someone send you some.</p>
<p>There is also no public test network yet. The SDKs and the wallet talk to mainnet, which is cheap enough to try with pocket money.</p>
<h2>What you can do in five minutes</h2>
<ul>
<li><strong>Look at it.</strong> The <a href="https://explorer.janzeer.org" target="_blank" rel="noopener">explorer</a> shows blocks, transactions, validators and a live animation of the consensus cycle.</li>
<li><strong>Hold it.</strong> The <a href="https://janzeer.org/wallet" target="_blank" rel="noopener">wallet</a> exists for Android, Linux, Windows and macOS, and in the browser inside the explorer. Keys stay on your device.</li>
<li><strong>Build on it.</strong> Official SDKs for <a href="https://github.com/janzeerOrg/janzeer-sdk-ts" target="_blank" rel="noopener">TypeScript</a>, <a href="https://github.com/janzeerOrg/janzeer-sdk-dart" target="_blank" rel="noopener">Dart</a>, <a href="https://github.com/janzeerOrg/janzeer-sdk-kotlin" target="_blank" rel="noopener">Kotlin</a>, <a href="https://github.com/janzeerOrg/janzeer-sdk-python" target="_blank" rel="noopener">Python</a> and <a href="https://github.com/janzeerOrg/janzeer-sdk-go" target="_blank" rel="noopener">Go</a>, all open source under Apache-2.0, all tested against the same byte-for-byte conformance vectors. A first transaction is about twenty lines in any of them; there is a <a href="https://www.youtube.com/@janzeerorg" target="_blank" rel="noopener">one-minute video</a> per language.</li>
<li><strong>Talk to it from a terminal.</strong> <a href="https://github.com/janzeerOrg/janzeer-cli" target="_blank" rel="noopener"><code>jz</code></a> is a 38 MB native command-line client: balances, blocks, a local encrypted wallet, sending, watching new blocks live.</li>
<li><strong>Run it.</strong> <a href="https://janzeer.org/validators" target="_blank" rel="noopener">Download the node bundle</a>, point it at mainnet, and it syncs. Registering as a validator is one command once it is in sync. The first ten outside operators get the 2,000 JNZ deposit covered by a grant.</li>
</ul>
<p>Links: <a href="https://janzeer.org/docs" target="_blank" rel="noopener">docs</a> · <a href="https://github.com/janzeerOrg" target="_blank" rel="noopener">source</a> · <a href="https://t.me/janzeerorg" target="_blank" rel="noopener">Telegram channel</a> · <a href="https://x.com/janzeerorg" target="_blank" rel="noopener">X</a> · <a href="https://www.youtube.com/@janzeerorg" target="_blank" rel="noopener">YouTube</a>.</p>
<h2>A word on how this was built</h2>
<p>I designed Janzeer and I run it, and I wrote large parts of the code and the documentation with an AI coding assistant, Claude Code, reviewing and testing everything: 214 automated tests boot real nodes in every build, every SDK is checked against shared vectors and a 14-step end-to-end flow on a real network before each release, and the chain ran a seven-day acceptance test before launch that produced 37 findings, all fixed first. Every number in this article comes from the live explorer, and the text is mine.</p>
<p>Tomorrow: why there is no staking, what the 2,000 JNZ deposit really buys, and how seats rotate.</p>]]></content:encoded>
    </item>
  </channel>
</rss>
