# Installing `junod`

Most operations in this skill assume `junod` (the Juno chain CLI / node binary) is on PATH. This file is what to do when it's not, and how to pick the right version.

## Check first

```bash
junod version
```

If you see `v29.x` (and your target is `juno-1` mainnet, which is the default), you're done — go back to your task.

## Version

For `juno-1` mainnet: **v29.x** (current chain-registry recommended). Upgrades to v30 are in flight; if v30 is active when you read this, use v30 — re-check chain-registry.

For the rare case you need uni-7 testnet: **v27.0.0** (the uni-7 README and chain-registry both pin this; later versions may panic on consensus state).

**Cross-version note:** running v29 against `uni-7` or v27 against `juno-1` will produce silent surprises — handshakes can succeed but the binary's understanding of recent governance-set params (gas, slashing, etc.) will be off. Use the right binary per chain.

If you need both chains in one session, install side-by-side and symlink whichever is primary (almost always mainnet):

```bash
/workspace/bin/junod         # symlink → junod-v29.x by default
/workspace/bin/junod-v29.x
/workspace/bin/junod-v27.0   # only if you actually need uni-7
```

## Install — release binary (recommended)

GitHub releases at `https://github.com/CosmosContracts/juno/releases` ship pre-built linux-amd64 binaries plus sha256 sidecars.

```bash
# Default: latest mainnet-compatible release. Check chain-registry to confirm.
VERSION=v29.0.0
BIN_DIR=/workspace/bin
mkdir -p "$BIN_DIR"
cd /tmp

curl -sL -o junod.bin \
  "https://github.com/CosmosContracts/juno/releases/download/${VERSION}/junod"
curl -sL -o junod_sha256.txt \
  "https://github.com/CosmosContracts/juno/releases/download/${VERSION}/junod_sha256.txt"

EXPECTED=$(awk '{print $1}' junod_sha256.txt)
ACTUAL=$(sha256sum junod.bin | awk '{print $1}')
if [ "$EXPECTED" != "$ACTUAL" ]; then
  echo "CHECKSUM MISMATCH: expected $EXPECTED got $ACTUAL"
  exit 1
fi

mv junod.bin "$BIN_DIR/junod"
chmod +x "$BIN_DIR/junod"
rm junod_sha256.txt

# Verify
"$BIN_DIR/junod" version
# should print the version (without the leading 'v' on most builds)
```

**Known sha256s** (cross-check against the release page, do not blindly trust this file):

| Version | sha256 |
|---|---|
| v27.0.0 | `aaf439b95ef213684819d4fbf0bdd38f782ec54d9f6f1f02ad0409f1097d8dcb` |

For other versions, the release page is authoritative.

## Install — from source (when no binary available)

If a target version doesn't have a published linux-amd64 binary (older or pre-release), build from the `CosmosContracts/juno` repo:

```bash
git clone https://github.com/CosmosContracts/juno.git
cd juno
git checkout v29.0.0           # whatever tag you want
make install                   # writes to $GOPATH/bin/junod
```

Requires Go matching the repo's `go.mod` `go` directive (currently 1.22+).

## PATH setup

If you put `junod` somewhere non-default (e.g., `/workspace/bin/`), add that to PATH:

```bash
export PATH="/workspace/bin:$PATH"
```

For a session-shell that needs it every time, append to `~/.zshrc` or `~/.bashrc` (or a project `.envrc` if using direnv).

## Recovery — binary corrupted or missing

The release binary is reproducible. To restore:

```bash
rm -f /workspace/bin/junod
# Re-run the install block above with the version you need.
```

No state is held in the binary itself — it's stateless. Your keys live in the keyring (see [`keys.md`](keys.md)) and your config lives in `~/.juno/config/` if you've initialized a node, which you usually haven't if you're just using junod as a CLI.

## Quick smoke test after install

```bash
# Talks to itself fine?
junod version
# expect: 29.x for mainnet work

# Talks to the network?
junod status --node https://juno-rpc.publicnode.com:443 -o json | jq -r '.node_info.network'
# expect: "juno-1"
```

If both work, you're ready to query, sign, and broadcast on mainnet. Go back to [`SKILL.md`](../SKILL.md) decision tree.