Introduction to Satsuma

Satsuma is a live, sovereign Layer-1 blockchain that runs Solidity smart contracts. It’s in production right now — sealing blocks, Ethereum-compatible, and open for anyone to read. This is the first post on the Satsuma engineering blog, so let’s take a visual tour: what Satsuma is, and the handful of deliberate choices that give it its shape.

Solidity, not a subset

Satsuma runs standard Solidity — not a dialect, not a restricted subset. The same contracts, the same language, the same mental model you already use on Ethereum. If you can write and deploy an ERC-20, an ERC-721, or a full DeFi protocol on an EVM chain, you can deploy it on Satsuma with the tools you already know.

That compatibility is the point. A new Layer-1 that asks developers to relearn everything starts with a tax nobody wants to pay. Satsuma removes that tax: bring your contracts, your libraries, and your workflow as-is.

Public to read, permissioned to write

Satsuma is a closed, permissioned Layer-1 — and that asymmetry is a feature, not a limitation. Anyone can read the chain; only an approved set can write to it.

• Public to read. Every block, address, and balance is open. The live explorer streams the head in real time — no account, no wallet.
• Permissioned to write. Who can submit transactions is controlled, which keeps the network predictable and abuse-resistant. That matters when a chain backs real applications rather than open speculation.

The result is transparency without the noise: the openness of a public ledger with the operational guarantees of a private network.

Fast, and final

Two numbers define the day-to-day feel of a chain: how often it produces blocks, and how quickly those blocks become irreversible.

Blocks seal roughly every two seconds, and finality is deterministic — once a block is finalized, it’s settled, with no probabilistic waiting and no reorgs to design around. For an application developer, a transaction you see confirmed is genuinely done, in seconds.

Solidity enabled, out of the box

Satsuma speaks EVM, so the standard Ethereum toolchain applies with no changes — the same contracts, the same Foundry/Hardhat workflow, the same wallets. Reading the chain is open to anyone; point any EVM tool at the RPC and query it:

# Reads are public — anyone can query the chain
export RPC_URL=https://rpc.satsuma.one/eth

cast chain-id     --rpc-url $RPC_URL   # 555555555
cast block-number --rpc-url $RPC_URL   # the live head

Writing is where the permissioning lives. Deploying contracts and sending transactions is plain Solidity — nothing Satsuma-specific to learn — but reserved for approved participants rather than open to the public. The capability is fully standard EVM; the access to write is controlled. And whatever does get written, anyone can read and audit in the explorer.

See it live

The best way to understand Satsuma is to watch it run. The explorer at explorer.satsuma.one shows the live head, block times, and finality as they happen — a permissioned chain sealing blocks on schedule, in the open.

Where this blog goes next

This is the introduction; the next posts go deeper. Expect architecture write-ups, performance work, and head-to-head comparisons with other chains — with the numbers to back them up. Follow along on X or Telegram, or grab the RSS feed.