juno: A Go repository from ssonthal

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

📌 Looking for a Starknet RPC Provider?

Access Nethermind's Starknet RPC service for free at https://data.voyager.online.

⚙️ Installation

Prerequisites

Golang 1.20 or higher is required to build and run the project. You can find the installer on the official Golang download page.
Rust.
A C compiler: gcc or clang.

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

📸 Snapshots

Use the provided snapshots to quickly sync your Juno node with the current state of the network.

Mainnet

Version	Size	Block	Download Link
>=v0.9.2	156 GB	519634	juno_mainnet.tar

Goerli

Version	Size	Block	Download Link
>=v0.9.2	48 GB	931113	juno_goerli.tar

Run Juno Using Snapshot

Download Snapshot

Fetch the snapshot from the provided URL:

wget -O juno_mainnet.tar https://juno-snapshots.nethermind.dev/mainnet/juno_mainnet_v0.9.3_519634.tar

Prepare Directory

Ensure you have a directory at $HOME/snapshots. If it doesn't exist yet, create it:
```
mkdir -p $HOME/snapshots
```
Extract Tarball

Extract the contents of the .tar file:
```
tar -xvf juno_mainnet.tar -C $HOME/snapshots
```

Run Juno

Execute the Docker command to run Juno, ensuring that you're using the correct snapshot path $HOME/snapshots/juno_mainnet:

docker run -d \
  --name juno \
  -p 6060:6060 \
  -v $HOME/snapshots/juno_mainnet:/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>

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

✔ Supported Features

Starknet v0.13.1 support.
JSON-RPC v0.7.0 (Available under /v0_7 and default/ endpoints)
- starknet_chainId
- starknet_blockNumber
- starknet_blockHashAndNumber
- starknet_getBlockWithTxHashes
- starknet_getBlockWithTxs
- starknet_getBlockWithReceipts
- starknet_getTransactionByHash
- starknet_getTransactionReceipt
- starknet_getBlockTransactionCount
- starknet_getTransactionByBlockIdAndIndex
- starknet_getStateUpdate
- starknet_getNonce
- starknet_getStorageAt
- starknet_getTransactionStatus
- starknet_getClassHashAt
- starknet_getClass
- starknet_getClassAt
- starknet_syncing
- starknet_getEvents
- starknet_call
- starknet_estimateFee
- starknet_addInvokeTransaction
- starknet_addDeclareTransaction
- starknet_addDeployAccountTransaction
- starkent_estimateMessageFee
- starknet_traceTransaction
- starknet_traceBlockTransactions
- starknet_simulateTransactions
- starknet_specVersion
Juno's JSON-RPC:
- juno_version
JSON-RPC v0.6.0 (Available under /v0_6 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.

🛣 Roadmap

Phase 1: Permissionless access to Starknet ✅

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.

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. 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.

🤝 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

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

ssonthal/juno