Janzeer blog ยท

Non-custodial by design: how Janzeer keys are made, and why the address is not an Ethereum address

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.

The last article 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.

The rule

Janzeer is non-custodial everywhere. In practice that means:

  • The node never sees a private key. 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.
  • Every wallet signs locally. The mobile and desktop wallet, the web wallet in the explorer, the wallet inside Telegram and the jz command-line client all derive keys and sign on the device, then send only the signed bytes.
  • Services built on top follow the same rule. The Telegram tip bot 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.

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.

From twelve words to a key

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.

The steps:

  1. Words to seed. 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.
  2. Seed to master key. An HMAC-SHA512 of the seed gives a master private key and a chain code.
  3. Master key to account key. The wallet derives the key at path m/0/0/0 on the secp256k1 curve, the same curve Bitcoin and Ethereum use.

Two of these steps use the string @_Janzeer_Blockchain_@ where the BIP39 and BIP32 standards use mnemonic and Bitcoin seed. 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.

From key to address

The address is the first 20 bytes of the Keccak-256 hash of the 33-byte compressed public key, written as 0x and 40 hex characters.

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.

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.

What a signature covers

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.

Two details protect users without their noticing:

  • The network id is part of what is signed. A transaction signed for the test network cannot be replayed on mainnet, or the other way round.
  • The nonce is part of what is signed. Each transaction from an account carries the next number in sequence, so a signed transaction can be applied once and never again.

Five SDKs, one set of answers

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.

The TypeScript, Dart, Kotlin, Python and Go SDKs and every wallet must reproduce that file byte for byte before a release. You can check one yourself: the test phrase abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about must give the address 0x06e1c0fa9955a700876f8cb0acc7f13fba9fb8ba in every one of them. Never send coins to it; everyone knows its key.

Keeping the words safe on a device

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 jz, so a wallet file exported from one of them opens in another with the same password.

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.

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.


Janzeer is built with AI assistance (Claude Code); every number here is from the live chain and the public documentation, and the text is mine. JNZ is the network's unit, it is not listed anywhere, and nothing in this series is financial advice.