Juno is a golang Starknet node implementation by Nethermind with the aim of decentralising Starknet.

ℹ️ Note: If you're looking to become a Starknet Validator, you’ll also need to run a validation tool. We’ve prepared a guide with detailed instructions. If you run into any issues, feel free to reach out to us.

⚙️ Installation

Prerequisites

• Golang 1.24 or higher is required to build and run the project. You can find the installer on the official Golang download page.

• Rust 1.86.0 or higher.

• A C compiler: gcc.

• Install some dependencies on your system:

  • macOS

    brew install jemalloc
    brew install pkg-config
    make install-deps

  • Ubuntu

    sudo apt-get install -y libjemalloc-dev libjemalloc2 pkg-config libbz2-dev
    make install-deps

• To ensure a successful build, you either need to synchronize the tags from the upstream repository or create a new tag.

Build and Run

make juno
./build/juno

Use the --help flag for configuration information. Flags and their values can also be placed in a .yaml file that is passed in through --config.

Run with Docker

To run Juno with Docker, use the following command. Make sure to create the $HOME/juno directory on your local machine before running the command.

docker run -d \
  --name juno \
  -p 6060:6060 \
  -v $HOME/juno:/var/lib/juno \
  nethermind/juno \
  --http \
  --http-port 6060 \
  --http-host 0.0.0.0 \
  --db-path /var/lib/juno \
  --eth-node <YOUR-ETH-NODE>

You should replace <YOUR-ETH-NODE> with your actual Ethereum node address. If you're using Infura, your Ethereum node address might look something like: wss://mainnet.infura.io/ws/v3/your-infura-project-id. Make sure you are using the websocket URL ws/wss and not the http URL http/https.

To view logs from the Docker container, use the following command:

docker logs -f juno

📚 Documentation

You can find Juno's full documentation here.

If you are looking to become a Starknet Validator, follow our guide here.

📸 Snapshots

Use the provided snapshots to quickly sync your Juno node with the current state of the network. Fresh snapshots are automatically uploaded once a week and are available under the links below.

Note: Snapshots are now provided in compressed .tar.zst format for faster downloads and reduced storage requirements. You can stream the download and extraction process without requiring double disk space.

Mainnet

Version	Download Link
>=v0.13.0	juno_mainnet.tar.zst

Sepolia

Version	Download Link
>=v0.13.0	juno_sepolia.tar.zst

Sepolia-Integration

Version	Download Link
>=v0.13.0	juno_sepolia_integration.tar.zst

Getting the size for each snapshot

$date
Mon 28 Jul 2025 08:24:59 GMT

$curl -s -I -L https://juno-snapshots.nethermind.io/files/mainnet/latest | gawk -v IGNORECASE=1 '/^Content-Length/ { printf "%.2f GB\n", $2/1024/1024/1024 }'
186.23 GB

$curl -s -I -L https://juno-snapshots.nethermind.io/files/sepolia/latest | gawk -v IGNORECASE=1 '/^Content-Length/ { printf "%.2f GB\n", $2/1024/1024/1024 }'
30.45 GB

$curl -s -I -L https://juno-snapshots.nethermind.io/files/sepolia-integration/latest | gawk -v IGNORECASE=1 '/^Content-Length/ { printf "%.2f GB\n", $2/1024/1024/1024 }'
6.14 GB

Run Juno Using Snapshot

This method downloads and extracts the snapshot in one step without requiring double disk space:

1. Prepare Directory

   Ensure you have a directory at $HOME/snapshots. If it doesn't exist yet, create it:

   mkdir -p $HOME/snapshots

2. Install zstd

   zstd (Zstandard) is required to decompress and directly stream the snapshots into your system without requiring temporary storage. zstd provides significantly better compression ratios and faster decompression speeds compared to traditional tar compression.

   # On Ubuntu/Debian
   sudo apt-get install zstd
   
   # On macOS
   brew install zstd
   
   # On RHEL/CentOS/Fedora
   sudo dnf install zstd  # or yum install zstd

3. Stream Download and Extract

   Download and extract the snapshot directly to your target directory:

   # For Mainnet
   curl -s -L https://juno-snapshots.nethermind.io/files/mainnet/latest \
   | zstd -d | tar -xvf - -C $HOME/snapshots

   For other networks, replace the URL:

   • Sepolia: https://juno-snapshots.nethermind.io/files/sepolia/latest
   • Sepolia-Integration: https://juno-snapshots.nethermind.io/files/sepolia-integration/latest

4. Run Juno

   Execute the Docker command to run Juno:

   docker run -d \
     --name juno \
     -p 6060:6060 \
     -v $HOME/snapshots:/var/lib/juno \
     nethermind/juno \
     --http \
     --http-port 6060 \
     --http-host 0.0.0.0 \
     --db-path /var/lib/juno \
     --eth-node <YOUR-ETH-NODE>

   Replace <YOUR-ETH-NODE> with your Ethereum node WebSocket URL (e.g., wss://mainnet.infura.io/ws/v3/your-project-id).

After following these steps, Juno should be up and running on your machine, utilizing the provided snapshot.

✔ Supported Features

• Starknet v0.14.0 support.

• JSON-RPC v0.9.0-rc1 (Available under /v0_9 and default/ endpoints)

  Chain/Network Information:

  • starknet_chainId
  • starknet_specVersion
  • starknet_syncing

  Block Related:

  • starknet_blockNumber
  • starknet_blockHashAndNumber
  • starknet_getBlockWithTxHashes
  • starknet_getBlockWithTxs
  • starknet_getBlockWithReceipts
  • starknet_getBlockTransactionCount

  Transaction Related:

  • starknet_getTransactionByHash
  • starknet_getTransactionReceipt
  • starknet_getTransactionByBlockIdAndIndex
  • starknet_getTransactionStatus
  • starknet_getMessagesStatus

  State & Storage:

  • starknet_getNonce
  • starknet_getStorageAt
  • starknet_getStorageProof
  • starknet_getStateUpdate

  Contract Related:

  • starknet_getClassHashAt
  • starknet_getClass
  • starknet_getClassAt
  • starknet_getCompiledCasm
  • starknet_call

  Event Related:

  • starknet_getEvents

  Write Operations:

  • starknet_addInvokeTransaction
  • starknet_addDeclareTransaction
  • starknet_addDeployAccountTransaction

  Fee Estimation & Simulation:

  • starknet_estimateFee
  • starknet_estimateMessageFee
  • starknet_simulateTransactions

  Tracing & Debug:

  • starknet_traceTransaction
  • starknet_traceBlockTransactions

  Websocket Subscriptions:

  • starknet_subscribeNewHeads
  • starknet_subscribeEvents
  • starknet_subscribeTransactionStatus
  • starknet_subscribePendingTransactions
  • starknet_unsubscribe

• Juno's JSON-RPC:

  • juno_version

• JSON-RPC v0.9.0-rc1 (Available under /v0_9 endpoint)

• JSON-RPC v0.8.0 (Available under /v0_8 endpoint)

• Integration of CairoVM.

• Verification of State from L1.

• Handle L1 and L2 Reorgs.

• Starknet state construction and storage using a path-based Merkle Patricia trie.

• Feeder gateway synchronisation of Blocks, Transactions, Receipts, State Updates and Classes.

• Block and Transaction hash verification.

• Plugins

🛣 Roadmap

Phase 1: Permissionless access to Starknet ✅

• Flat DB implementation of trie
• Go implementation of crypto primitives
  • Pedersen hash
  • Starknet_Keccak
  • Felt
• Feeder gateway synchronisation
  • State Update
  • Blocks
  • Transactions
  • Class
• Implement the following core data structures, and their Hash calculations
  • Blocks
  • Transactions and Transaction Receipts
  • Contracts and Classes
• Storing blocks, transactions and State updates in a local DB
• Basic RPC (in progress)
  • starknet_chainId
  • starknet_blockNumber
  • starknet_blockHashAndNumber
  • starknet_getBlockWithTxHashes
  • starknet_getBlockWithTxs
  • starknet_getTransactionByHash
  • starknet_getTransactionReceipt
  • starknet_getBlockTransactionCount
  • starknet_getTransactionByBlockIdAndIndex
  • starknet_getStateUpdate

Phase 2: Full JSON RPC Support ✅

The focus of Phase 2 will be to Verify the state from layer 1 and implement the remaining JSON-RPC endpoints.

• Starknet v0.11.0 support
  • Poseidon state trie support
• Blockchain: implement blockchain reorganization logic.
• Synchronisation: implement verification of state from layer 1.
• JSON-RPC API v0.3.0:
  • Implement the remaining endpoints:
    • starknet_syncing
    • starknet_getNonce
    • starknet_getStorageAt
    • starknet_getClassHashAt
    • starknet_getClass
    • starknet_getClassAt
    • starknet_getEvents
• Integration of CairoVM:
  • starknet_call
  • starknet_estimateFee
• JSON-RPC Write API v0.3.0:
  • starknet_addInvokeTransaction
  • starknet_addDeclareTransaction
  • starknet_addDeployAccountTransaction

Phase 3: Starknet decentralization begins 🚧

Juno can synchronize Starknet state from other full nodes with the aim of decentralizing Starknet by removing the dependency from the centralized sequencer.

Snap sync is implemented, significantly reducing sync times.

Phase 4: Juno becomes a Starknet Sequencer 🔜

The decentralization of Starknet is complete! Juno becomes a sequencer and participates in L2 consensus to secure the network. Juno has multiple modes of operation: ‍

• Light client: provides fast permissionless access to Starknet with minimal verification.

• Full Node: complete verification of Starknet state along with transaction execution.

• Sequencer: secure the network by taking part in the L2 consensus mechanism.

👍 Contribute

We welcome PRs from external contributors and would love to help you get up to speed. Let us know you're interested in the Discord server and we can discuss good first issues.

For more details on how to get started, check out our contributing guidelines.

There are also many other ways to contribute. Here are some ideas:

• Run a node.
• Add a GitHub Star to the project.
• Tweet about Juno.
• Add a Github issue if you find a bug, or you need or want a new feature.

📞 Contact us

For questions or feedback, please don't hesitate to reach out to us:

• Telegram
• Discord
• X(Formerly Twitter)

🤝 Partnerships

To establish a partnership with the Juno team, or if you have any suggestion or special request, feel free to reach us via email.

⚠️ License

Copyright (c) 2022-present, with the following contributors.

Juno is open-source software licensed under the Apache-2.0 License.