YSKAR

A chain of its own.

YSKAR does not run on top of another network. It has its own blocks, its own peer-to-peer network and its own rules, and it proves every block with work that anyone can check.

One block, three steps.

Miners search

Phones, PCs and graphics cards hash a block header over and over, each time with a different nonce. A hash below the target makes the block valid.

Nodes check

Every full node recomputes the work, the signatures and all balances, starting at block 0. A block that breaks a rule is rejected, whoever sent it.

The block pays

The block itself pays the reward: to the finder alone, or split among the miners of a pool, straight to their addresses. A pool never holds anyone else's coins.

Why an own chain matters

Its rules are its own

Fees, block times and upgrades are decided here, by the people who run YSKAR, and by nobody else's network.

Nothing to take on trust

Every block back to block 0 can be recomputed by anyone, with open software, on an ordinary computer.

Changes arrive in the open

A rule change is written into the code together with the block at which it starts. Every node knows it in advance. Revision 6 was put to a community vote.

For the curious: how it works in detail

From here on the page gets technical. Everything below comes from the consensus code and from the chain itself.

Work that anyone can check

A block is valid only if its hash, read as a number, is not larger than a target. The target follows from the difficulty. There is no shortcut: the only way to find such a hash is to try nonces, and checking the result takes two hash computations.

target = floor(2240 / difficulty) valid: sha256(sha256(header)) ≤ target

One unit of difficulty stands for 65,536 expected attempts. At the current difficulty of , the network needs about attempts for one block.

Search for a nonce yourself Runs in your browser

Your browser takes the header of the latest block and tries nonces against an easier target. The real target is far beyond what a browser can reach.


Attempts0
Speed—
Time—
Nonce found—

Last hash tried—
Target of this demo

The difficulty follows the network

The difficulty is recomputed for every block from the last 45 blocks. Recent blocks count more than older ones, so the chain reacts quickly when hash power arrives or leaves.

Every node computes the same range from the same blocks and rejects a block that states a difficulty outside it. Only whole numbers are used, so two nodes can never round differently.

Difficulty since block 1

Mean of every 24 blocks up to block . The scale is logarithmic: each line is ten times the one below.

Show the values as a table
Window
the last 45 blocks, the newest weighted highest
Largest step
a factor of 4 up or down per block
Solve time counted
1 to 3,600 seconds per block
Emergency rule
after 1,800 seconds without a block, the requirement falls in proportion to the waiting time
Timestamps
later than the median of the last 11 blocks, at most 120 seconds ahead of the node's clock

Accounts and transfers

YSKAR keeps one balance and one nonce per address. A transfer names sender, recipient, amount and fee, and is signed with the sender's key. Without that key nobody can move the coins.

The state root in every header commits to all balances. A node that replays the chain from block 0 arrives at the same balances as every other node, or it rejects the block.

A transfer, 168 bytes

Plus an optional note of up to 32 bytes. Sizes in bytes.

  1. Version and type3
  2. Sender address20
  3. Recipient address20
  4. Amount8
  5. Fee8
  6. Sender's nonce8
  7. Expiry height and note length5
  8. Public key32
  9. Signature64
Valid once
The nonce must equal the number of transfers the sender has made so far, so the same transfer can never be applied twice.
Tied to this network
The signature covers the chain ID. A transfer signed for YSKAR is invalid anywhere else.
Expiry
A sender can name a last block height. After it, the transfer can never be included.
Note
Up to 32 bytes, stored publicly in the chain.
Minimum fee
1 unit per byte by consensus. Nodes relay from 10 units per byte. Fees go to the miners of the block.
A plain transfer costs
right now at least

A wallet is 12 or 24 words (BIP39). The key is derived from them on the device (SLIP-0010), and the address is the first 20 bytes of the SHA-256 hash of the public key, written in bech32m. The words never leave the device that created them.

Every node checks every block

A full node stores the whole chain and accepts a block only after it has checked it completely, whether the block comes from another node or from its own miner. The checks run in this order.

Run a full node
  1. Structure

    Version, at most 2,000 transactions, exactly one reward transaction in first place, and the transaction root.

  2. Proof of work

    The hash of the header, applied twice, is not larger than the target of the stated difficulty.

  3. Place in the chain

    The height is the parent's height plus one, and the previous hash is the hash of the parent.

  4. Timestamp

    Later than the median of the last 11 blocks, not before the parent, and at most 120 seconds ahead of the node's clock.

  5. Difficulty

    The stated difficulty lies in the range that follows from the previous blocks.

  6. Every transaction

    Signature, sender, nonce, balance, fee and expiry of every transfer. The reward transaction pays exactly the block reward plus the fees.

  7. State root

    The root over all accounts after the block equals the state root in the header.

Which chain counts

The valid chain with the most accumulated work, where the work of a block is its difficulty. A node keeps competing blocks and switches when another branch has more work.

Pools without custody

The reward transaction of a block may pay up to 64 addresses. A pool's accounting becomes that transaction, so the chain pays every miner directly and the operator never holds anyone else's coins. How pools work

Rules change at a block height

A rule change is written into the code together with the height at which it starts. Every node switches at the same block, and every block below that height keeps its rules, byte for byte.

RevisionFrom blockChangeStatus
22,000The reward transaction may pay several addresses. Pools are built on this.
34,000A minimum fee per byte replaces the fixed fee, and a smallest amount applies.
46,000The difficulty field can hold values of any size.
57,000Stricter rules for timestamps, block encoding and the reward transaction.
610,000Shared accounts, time and hash locks, batch payments, a new state tree and higher limits.

Revisions 2 to 5 corrected and tightened rules. Revision 6 is the first that adds capabilities, and the first that older nodes cannot follow.

Revision 6

The next rule change starts at block 10,000. The community chose that height in a vote on 25 October 2026. It changes the account record, the address format and the transaction format, so that accounts can do more than hold a balance.

Block 10,000
Read the specification of revision 6

Shared accounts

Accounts that need several signatures to spend, for example 2 of 3, with up to 16 keys. For shared funds and safer savings.

Time locks

YSR that can only be spent from a chosen block height on.

Hash locks

A payment is released only against a secret, and returns to the sender after a set height. Two parties can trade without trusting each other.

Batch payments

One transaction pays up to 1,000 recipients at once.

More room per block

Up to 5,000 transactions per block instead of 2,000, and a pool's block can pay up to 255 addresses instead of 64.

A foundation for later

A state tree built for many thousands of accounts, addresses with a version, and a fork identifier in every signature.

What stays the same

  • 21 million YSR and the halving schedule
  • 10-minute blocks, SHA-256 and the difficulty rules
  • Every address, every key and every balance

What you need to do

  • Update your wallet and your node before block 10,000
  • Miners, the GPU miners and the HiveOS package need no update
  • An outdated wallet still receives YSR. It cannot send until it is updated

Known limits

What the system does not protect against today. The list comes from the project's own security document.

The full security model
A small network
The network has two seed nodes, both run by the same operator. Proof of work protects a chain only as long as no single party controls most of the hash power, and hash power that mines through one pool is directed by that pool's operator.
No checkpoints
A node switches to any valid chain with more work, however far back it forks. Treat a transfer as more final the more blocks are built on top of it.
The explorer's data source
Explorer and apps read from a mirror, a database copy of the chain kept for speed. It is a convenience, not the authority: the chain is what the full nodes agree on.
Pool seats
A pool has at most 64 seats, 63 if it charges a fee; from revision 6 it is 255 and 254. Opening a session needs only a valid address, so seats can be occupied cheaply.
Open interfaces
A node's HTTP interface does not limit requests per client. On a public node, a reverse proxy has to do that.
The same fjord at first light: a pale sky over snow-covered mountains and still water.

It's still early here.

Day . The first light is only just coming up over this network. The people who shape it are the ones who are here now.