Shielded Vote Validator Setup

Fresh Join

Use Automatic for the supported install path. Switch to Manual when you need to build from source, manage TLS yourself, or run each setup stage directly.

Provision The Validator Host

Minimum production requirement: use at least this host size before running Fresh Join.

Platform

Linux amd64

CPU

4 vCPU

Memory

8 GB RAM

Storage

120 GB NVMe

Linux arm64 is also supported. macOS builds are for local development, not production validators.
Run Fresh Join

Run this on the validator host. It initializes the validator, restores or syncs chain data, registers the operator for approval, and starts the local service.
```
curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/join.sh | bash
```
The helper server runs with svoted on local port 1317. Wallets submit shares to a public HTTPS URL, so the installer asks how to expose that helper API:
1. Skip Caddy. Use this if you already handle the public HTTPS certificate with a load balancer or reverse proxy.
2. Custom domain + Caddy. The script installs Caddy, gets a Let's Encrypt certificate, and proxies https://your-domain to localhost:1317.
3. Auto sslip.io + Caddy. The script builds a public HTTPS URL from the host's detected IPv4, installs Caddy, and proxies it to localhost:1317.
When registration finishes, contact Valar Group and tell them your validator is pending approval.
Publish The Vote Server URL

Add the public HTTPS helper URL to vote_servers[] in prod/dynamic-voting-config.json. If Fresh Join configured Caddy, use the URL it prints. If you skipped Caddy, use the public URL from your own HTTPS proxy. Add one JSON object with url and label, then open a PR from GitHub's edit flow. This can be done while the validator is still pending approval. Edit voting config. For a concrete example, see this merged voting config PR.
Back Up Validator Identity

Back up config/priv_validator_key.json, config/node_key.json, keyring-test/, pallas.*, and ea.* encrypted off-host. Keep the validator signing key live on exactly one host.

Install Source Build Requirements

Minimum production requirement: use at least this host size before building and joining a validator manually. Use Linux for production validators; macOS source builds are for local development.

Platform

Linux amd64

CPU

4 vCPU

Memory

8 GB RAM

Storage

120 GB NVMe
```
sudo apt-get update
sudo apt-get install -y curl git jq lz4 ca-certificates build-essential pkg-config clang lld
command -v mise >/dev/null 2>&1 || curl https://mise.run | sh
export PATH="$HOME/.local/bin:$PATH"
```

Build The Active Chain Version

Build from the release tag reported by the current seed node. Running a different app version can cause replay or app-hash failures after snapshot restore.

git clone https://github.com/valargroup/vote-sdk.git
cd vote-sdk
mise install
export PATH="$HOME/go/bin:$PATH"

VOTING_CONFIG_URL="${VOTING_CONFIG_URL:-https://voting.valargroup.dev/prod/dynamic-voting-config.json}"
VOTING_CONFIG=$(curl -fsSL "$VOTING_CONFIG_URL")
SEED_URL=$(echo "$VOTING_CONFIG" | jq -r '.vote_servers[0].url')
NODE_INFO=$(curl -fsSL "${SEED_URL%/}/cosmos/base/tendermint/v1beta1/node_info")

NODE_ID=$(echo "$NODE_INFO" | jq -r '.default_node_info.default_node_id // .default_node_info.id')
LISTEN_ADDR=$(echo "$NODE_INFO" | jq -r '.default_node_info.listen_addr')
CHAIN_BINARY_VERSION=$(echo "$NODE_INFO" | jq -r '.application_version.version')
SEED_HOST=$(echo "$SEED_URL" | sed -E 's|^https?://||; s|:[0-9]+$||; s|/.*||')
P2P_PORT=$(echo "$LISTEN_ADDR" | sed -E 's|.*:([0-9]+)$|\1|')
PERSISTENT_PEERS="${NODE_ID}@${SEED_HOST}:${P2P_PORT:-26656}"

git fetch --tags
git checkout "$CHAIN_BINARY_VERSION"
mise install
mise run install

LOCAL_SVOTED_VERSION=$(svoted version 2>/dev/null | tr -d '[:space:]')
test "$LOCAL_SVOTED_VERSION" = "$CHAIN_BINARY_VERSION"

mise run install is the source-build task; it is also available as mise run build:install.

Initialize State And Restore Snapshot

This creates a fresh validator home, installs canonical genesis, and restores the latest snapshot when one is published. Set MONIKER to the validator name admins should see in the join queue. If no snapshot metadata exists, sync from genesis.

MONIKER="my-validator"
HOME_DIR="$HOME/.svoted"
rm -rf "$HOME_DIR"

svoted init "$MONIKER" --chain-id zvote-1 --home "$HOME_DIR"

GENESIS_TMP=$(mktemp)
LIVE_GENESIS_TMP=$(mktemp)
curl -fsSL -o "$GENESIS_TMP" https://shielded-vote.nyc3.digitaloceanspaces.com/genesis.json
if curl -fsSL -o "$LIVE_GENESIS_TMP" "${SEED_URL%/}/shielded-vote/v1/genesis" 2>/dev/null; then
  cmp -s "$GENESIS_TMP" "$LIVE_GENESIS_TMP" || cp "$LIVE_GENESIS_TMP" "$GENESIS_TMP"
fi
cp "$GENESIS_TMP" "$HOME_DIR/config/genesis.json"
svoted genesis validate-genesis --home "$HOME_DIR"

SNAPSHOT_META=$(mktemp)
SNAPSHOT_ARCHIVE=$(mktemp)
VALIDATOR_STATE=$(mktemp)
if curl -fsSL -o "$SNAPSHOT_META" https://snapshots.valargroup.org/latest.json; then
  test "$(jq -r '.chain_id' "$SNAPSHOT_META")" = "zvote-1"
  SNAPSHOT_URL=$(jq -r '.url' "$SNAPSHOT_META")
  SNAPSHOT_SUM=$(jq -r '.checksum' "$SNAPSHOT_META")
  curl -fL -o "$SNAPSHOT_ARCHIVE" "$SNAPSHOT_URL"
  ACTUAL_SUM=$(sha256sum "$SNAPSHOT_ARCHIVE" | awk '{print $1}')
  test "$ACTUAL_SUM" = "$SNAPSHOT_SUM"
  cp "$HOME_DIR/data/priv_validator_state.json" "$VALIDATOR_STATE"
  rm -rf "$HOME_DIR/data"
  lz4 -dc "$SNAPSHOT_ARCHIVE" | tar -C "$HOME_DIR" -xf -
  cp "$VALIDATOR_STATE" "$HOME_DIR/data/priv_validator_state.json"
  rm -rf "$HOME_DIR/data/cs.wal"
else
  echo "No snapshot metadata is available; the node will sync from genesis."
fi

Generate Keys And Configure The Node

This creates validator, Pallas, and EA keys; then it points CometBFT at the seed peer and enables the REST helper on local port 1317.

svoted init-validator-keys --home "$HOME_DIR"
VALIDATOR_ADDR=$(svoted keys show validator -a --keyring-backend test --home "$HOME_DIR")
VALIDATOR_VALOPER=$(svoted keys show validator --bech val -a --keyring-backend test --home "$HOME_DIR")

CONFIG_TOML="$HOME_DIR/config/config.toml"
APP_TOML="$HOME_DIR/config/app.toml"

sed -i.bak "s|persistent_peers = \"\"|persistent_peers = \"${PERSISTENT_PEERS}\"|" "$CONFIG_TOML"
sed -i.bak '/\[api\]/,/\[.*\]/ s/enable = false/enable = true/' "$APP_TOML"
sed -i.bak '/\[api\]/,/\[.*\]/ s/enabled-unsafe-cors = false/enabled-unsafe-cors = true/' "$APP_TOML"
sed -i.bak "s|\\$HOME/.svoted|${HOME_DIR}|g" "$APP_TOML"
rm -f "${CONFIG_TOML}.bak" "${APP_TOML}.bak"

cat >> "$APP_TOML" <<'HELPERCFG'

[helper]
disable = false
api_token = ""
db_path = ""
chain_api_port = 1317
max_concurrent_proofs = 8
HELPERCFG

Expose HTTPS To The Helper API

Wallets need a public HTTPS URL that proxies to localhost:1317. Use your own load balancer or configure Caddy. This step must leave VALIDATOR_URL set to the public HTTPS URL that should be published for wallets.
```
VALIDATOR_DOMAIN="validator.example.org"
VALIDATOR_URL="https://${VALIDATOR_DOMAIN}"

sudo apt-get install -y caddy
sudo tee /etc/caddy/Caddyfile > /dev/null <<EOF
${VALIDATOR_DOMAIN} {
    reverse_proxy localhost:1317
}
EOF
sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl restart caddy
```
If TLS is handled upstream, skip the Caddy block and set VALIDATOR_URL directly before continuing.
```
VALIDATOR_URL="https://validator.example.org"
```

Register For Funding Approval

Run this after VALIDATOR_URL is set, whether you configured Caddy or use upstream TLS. This is the funding and approval request: it sends your operator address, public URL, and MONIKER to the primary admin API.

SVOTE_ADMIN_URL="${SVOTE_ADMIN_URL:-https://vote-chain-primary.valargroup.org}"
TIMESTAMP=$(date +%s)

REG_PAYLOAD=$(jq -nc \
  --arg oa "$VALIDATOR_ADDR" \
  --arg u "${VALIDATOR_URL:-}" \
  --arg m "$MONIKER" \
  --argjson ts "$TIMESTAMP" \
  '{operator_address:$oa,url:$u,moniker:$m,timestamp:$ts}')

SIG_JSON=$(svoted sign-arbitrary "$REG_PAYLOAD" --from validator --keyring-backend test --home "$HOME_DIR")
SIG=$(echo "$SIG_JSON" | jq -r '.signature')
PUB_KEY=$(echo "$SIG_JSON" | jq -r '.pub_key')

REG_BODY=$(jq -nc \
  --arg oa "$VALIDATOR_ADDR" \
  --arg u "${VALIDATOR_URL:-}" \
  --arg m "$MONIKER" \
  --argjson ts "$TIMESTAMP" \
  --arg s "$SIG" \
  --arg pk "$PUB_KEY" \
  '{operator_address:$oa,url:$u,moniker:$m,timestamp:$ts,signature:$s,pub_key:$pk}')

curl -fsSL -X POST "${SVOTE_ADMIN_URL%/}/api/register-validator" \
  -H "Content-Type: application/json" \
  -d "$REG_BODY" | jq

When the response shows pending or registered, message the voting admin with the validator name and operator address so they can approve and fund it.

Install Cosmovisor

These Linux steps use Cosmovisor, matching the default in join.sh. Cosmovisor runs the current chain binary and switches to the new binary at a scheduled upgrade height. Run this from the source checkout used above. The shared installer verifies the Cosmovisor download checksum and stages the current svoted binary under $HOME_DIR/cosmovisor/genesis/bin/svoted.
```
INSTALL_DIR="${GOBIN:-$HOME/go/bin}"
SVOTED_BIN=$(command -v svoted)

(
  set -euo pipefail
  export SVOTE_HOME="$HOME_DIR"
  export SVOTE_INSTALL_DIR="$INSTALL_DIR"
  source scripts/_chain_upgrade_common.sh
  svote_upgrade_resolve_paths

  COSMOVISOR_TMP=$(mktemp -d)
  trap 'rm -rf "$COSMOVISOR_TMP"' EXIT
  svote_upgrade_install_cosmovisor "$COSMOVISOR_TMP"
  svote_upgrade_stage_binary "$SVOTED_BIN" "$GENESIS_BIN"
)
```

Install The Wrapper Service

The wrapper starts svoted through Cosmovisor, waits for sync and vote-manager funding, runs create-val-tx, then writes join-complete after bonding. The service enables checksum-required upgrade downloads and restarts the chain binary after an upgrade.

As in join.sh, UNSAFE_SKIP_BACKUP=true skips Cosmovisor's local pre-upgrade chain data copy to avoid duplicate storage use. Recovery requires an external backup or a fresh Valar snapshot. Keep validator identity files encrypted off-host.

WRAPPER_BIN="${INSTALL_DIR}/svoted-wrapper.sh"
cp scripts/svoted-wrapper.sh "$WRAPPER_BIN"
chmod +x "$WRAPPER_BIN"

sudo tee /etc/systemd/system/svoted.service > /dev/null <<EOF
[Unit]
Description=Shielded-Vote validator (${MONIKER})
After=network.target

[Service]
Type=simple
User=$(whoami)
Environment="PATH=${INSTALL_DIR}:/usr/local/bin:/usr/bin:/bin" "SVOTE_HOME=${HOME_DIR}" "VALIDATOR_ADDR=${VALIDATOR_ADDR}" "VALIDATOR_VALOPER=${VALIDATOR_VALOPER}" "MONIKER=${MONIKER}" "SVOTE_INSTALL_DIR=${INSTALL_DIR}" "SVOTED_BIN=${SVOTED_BIN}"
Environment="SVOTE_CHAIN_ID=zvote-1" "SVOTE_UPGRADE_MODE=cosmovisor"
Environment="DAEMON_HOME=${HOME_DIR}" "DAEMON_NAME=svoted" "COSMOVISOR_BIN=${INSTALL_DIR}/cosmovisor"
Environment="DAEMON_RESTART_AFTER_UPGRADE=true" "DAEMON_ALLOW_DOWNLOAD_BINARIES=true" "DAEMON_DOWNLOAD_MUST_HAVE_CHECKSUM=true" "UNSAFE_SKIP_BACKUP=true"
ExecStart=${WRAPPER_BIN}
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable svoted
sudo systemctl restart svoted

Verify, Publish, And Back Up

Confirm the service process tree shows Cosmovisor with one svoted child. Watch the service until the node is synced and the join queue shows the operator. After bonding, publish the public helper URL to vote_servers[] and back up validator identity files encrypted off-host.
```
sudo systemctl status svoted --no-pager
journalctl -u svoted -f
svoted status --home "$HOME_DIR" | jq '{network: .node_info.network, height: .sync_info.latest_block_height, catching_up: .sync_info.catching_up}'
curl -fsS http://127.0.0.1:1317/cosmos/base/tendermint/v1beta1/node_info | jq '.default_node_info.network'
curl -fsS "${VALIDATOR_URL}/shielded-vote/v1/genesis" > /dev/null && echo "public helper OK"
```
Back up config/priv_validator_key.json, config/node_key.json, keyring-test/, pallas.*, and ea.*. Keep the validator signing key live on exactly one host. Edit voting config.

What Your Validator Does

A validator is more than a block producer. It helps keep the private-voting protocol live while preserving the rule that no single party can decrypt individual votes.

Runs consensus. Your node participates in the CometBFT validator set, proposes and votes on blocks, and verifies the Shielded Vote transactions that enter the chain.
Publishes a vote server. The public HTTPS helper URL lets wallets submit encrypted vote-share payloads. The helper stores them durably, waits until the wallet-provided submit_at time, generates the share reveal proof, and submits MsgRevealShare to the chain.
Participates in DKG. When a vote manager starts a round, the chain snapshots eligible validators. Each validator automatically contributes Joint-Feldman DKG material, encrypts per-validator shares with ECIES, verifies the shares it receives, and acks the ceremony. The result is an election authority public key; the private key is never assembled by one validator.
Protects private tallying. Wallet votes are ElGamal encrypted to the election authority public key, and the chain accumulates only encrypted totals while the vote is open. When the round moves to tallying, validators automatically submit threshold partial decryptions for the encrypted accumulators.
Finalizes aggregate results. Once enough partial decryptions are on-chain, a proposer combines them and submits the plaintext totals. Individual votes are not decrypted; only the aggregate result for each option becomes public.

Safe Snapshot Reset

curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/reset-validator-snapshot.sh | env \
  SVOTE_CHAIN_ID=zvote-1 \
  SVOTE_SNAPSHOT_BASE_URL=https://snapshots.valargroup.org \
  bash

Use this on an existing validator when chain data needs to be replaced from the latest pruned snapshot. The command pins the chain ID and snapshot service shown by this page.

Optional overrides

Variable	Default	Meaning
`SVOTE_HOME`	`$HOME/.svoted`	Existing validator home to reset.
`SVOTE_SNAPSHOT_BASE_URL`	`https://snapshots.valargroup.org`	Snapshot service base URL.
`SVOTE_SERVICE_NAME`	`svoted`	systemd service name on Linux.
`SVOTE_POST_RESTART_SYNC_TIMEOUT`	`600`	Seconds to wait after restart for `catching_up=false`.
`SVOTE_TMPDIR`	`${TMPDIR:-/tmp}`	Parent directory for staged snapshot files.

Node Operations

Follow service logs

journalctl -u svoted -f

View syncing status

svoted status --home ~/.svoted | jq '{height: .sync_info.latest_block_height, catching_up: .sync_info.catching_up}'

Monitor The Vote

Use the admin dashboard's active vote page to monitor the live round: Open vote status.

Monitor status. This page shows whether the vote is pending, active, tallying, or finalized, plus the information validators need to confirm the vote is progressing. The same dashboard also includes tools for preparing and publishing voting rounds, so validators may see sections that are not part of normal validator monitoring.
Interpreting shares. Shares will trickle in for each option during the voting period. The option with the most shares is not necessarily the option with the most voting power behind it: up to 5 notes from a single voter are split across 16 shares, and each share's value depends on the voter's hidden note values. The actual result is only known after the vote reaches tallying and finalizes; there is no public running vote-power total, only the final aggregate.

Coordinated Upgrade

Coordinated chain upgrades require validators to change binaries at the same height. The full process is:

Coordinators schedule the upgrade at a future height.
At that height the running process stops for all validators.
Validators swap in the updated binary and restart.
Once 2/3 of the voting power comes back online, the chain continues.

The supported path below uses Cosmovisor to perform the binary swap automatically. It also configures checksum-verified downloads and lets you pre-stage the current upgrade for an advance check.

Preparing in advance, by pre-downloading the binaries and configuring checksum-required Cosmovisor auto-download, avoids manual work during this and future upgrade halts.

Important:

Never run the same priv_validator_key.json on more than one process, to avoid double-signing.
Once this setup is complete, manage the validator only through svoted.service. Do not also run svoted start manually. Cosmovisor running with one child svoted process is the expected setup.
Ensure that you are aware of how your binary is configured: regular systemd, Cosmovisor or simply running the binary directly.

What is Cosmovisor?

Cosmovisor is the Cosmos SDK process manager for chain binaries. It runs your validator binary and, at a scheduled upgrade height, switches to the upgrade binary automatically. If the binary was not pre-staged, Cosmovisor can download it from the checksum-pinned URL in the on-chain plan.

Official docs: Cosmovisor documentation.
Vote runbook: Software upgrade runbook.

These commands support the recommended validator setup. If your hardware or service layout differs from the documented setup, contact us before proceeding.

Automatic download and pre-staging are separate. Automatic download lets Cosmovisor fetch a checksum-pinned binary at the halt if it is not already present. Pre-staging is recommended because it removes that network dependency from the halt.

Choose Your Current Setup

Select how your validator runs today, then follow every step shown for that path.

This path keeps your current Cosmovisor service, enables checksum-required downloads, and pre-stages this upgrade.

Confirm Release And Plan Status

Use a published, verified release and a plan that has not already been applied on this chain.

Wait until the coordinator has scheduled the upgrade plan before following these steps. Review the plan name, halt height, and release tag on the upgrades page: Open scheduled upgrades. Find the environment variable values under Current plan on that page, then set these once and reuse them in every step below.
```
PLAN_NAME=v1.6.0
RELEASE_TAG=v1.6.0
UPGRADE_SCRIPT_VERSION=v1.6.0
CHAIN_API=https://vote-chain-primary.valargroup.org
```

Pre-Stage The Upgrade Binary

This downloads and verifies the release without stopping the running validator.

curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/scripts/upgrade/$UPGRADE_SCRIPT_VERSION/update_chain.sh | sudo bash -s -- \
  --mode prepare --plan-name "$PLAN_NAME" --tag "$RELEASE_TAG" --chain-api "$CHAIN_API"

One-Time Migrate

This moves the service under Cosmovisor and briefly restarts it with the current binary. It does not start the new release early. If an earlier direct upgrade left an old marker, the script archives it only after its name and height are confirmed as applied on this chain. It also refuses to start Cosmovisor while another signer process is running.
```
curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/scripts/upgrade/$UPGRADE_SCRIPT_VERSION/update_chain.sh | sudo bash -s -- \
  --mode migrate --plan-name "$PLAN_NAME" --tag "$RELEASE_TAG" --chain-api "$CHAIN_API"
```
Enable Automatic Downloads

Run this once after the service is under Cosmovisor. It allows downloads only from an on-chain upgrade plan and refuses any download without a checksum. The guarded restart keeps running the current binary and fails if it finds another signer process.
```
curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/scripts/upgrade/$UPGRADE_SCRIPT_VERSION/update_chain.sh | sudo bash -s -- \
  --mode configure-autodownload --plan-name "$PLAN_NAME" --tag "$RELEASE_TAG" --chain-api "$CHAIN_API"
```

Verify Scheduled Readiness (PASS/FAIL)

Do not proceed on a failed pre-stage check. The final two lines must both report true from the running Cosmovisor process. The checklist also requires exactly one Cosmovisor-managed svoted signer.

# Run after the coordinator has scheduled the plan.
curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/scripts/upgrade/$UPGRADE_SCRIPT_VERSION/update_chain.sh | sudo bash -s -- \
  --mode verify-prestage --plan-name "$PLAN_NAME" --tag "$RELEASE_TAG" --chain-api "$CHAIN_API"

sudo systemctl is-active svoted
sudo sh -c 'tr "\0" "\n" <"/proc/$(systemctl show svoted -p MainPID --value)/environ"' \
  | grep -E '^DAEMON_(ALLOW_DOWNLOAD_BINARIES|DOWNLOAD_MUST_HAVE_CHECKSUM)=true$'

If verify-prestage fails, stay on the current binary and re-run --mode prepare with the exact plan name. Full operator checklist: Software upgrade runbook.

Disable Automatic Upgrade Backups

Run this once on each validator well before a scheduled upgrade. It permanently disables Cosmovisor's local pre-upgrade data copy and removes every existing data-backup-Y-M-D directory. Afterward, rollback requires your own external backup or a fresh Valar snapshot.

The script confirms the chain ID, active systemd service, Cosmovisor process tree, validator home, current binary link, and every deletion target. It briefly restarts svoted.service, verifies that UNSAFE_SKIP_BACKUP=true reached the running process, and only then removes the old backups. Active chain data, Cosmovisor binaries, validator keys, and off-host backups are not removed.

(
set -euo pipefail

script="$(mktemp)"
trap 'rm -f "$script"' EXIT

curl -fsSL \
  "https://shielded-vote.nyc3.digitaloceanspaces.com/scripts/disable-cosmovisor-backups/v1/disable-cosmovisor-backups.sh" \
  -o "$script"
printf '%s  %s\n' '86e8f293478090495eb8c7d53b6f5dae8b38e6a947f4e7a6749d387abd62eb1f' "$script" | sha256sum --check -

sudo bash "$script" \
  --apply \
  --service-name svoted \
  --expected-chain-id zvote-1
)

Do not run this during a chain halt or an upgrade. If the script refuses an unusual service or storage layout, do not bypass the check; contact Valar Group with the printed error.

Destructive Validator Teardown Permanently removes local validator data, keys, and services.

Validator Teardown

This permanently removes the local validator home, validator keys, chain data, and services. If the validator identity files were not backed up first, this operator must join again as a new validator and wait for approval before participating.

Use this when a test host should stop being a validator. If a vote is already in progress, remove or replace this host's public URL in vote_servers[] before clients depend on it.

Run The Teardown Script

Run this on the validator host. The script requires typing REMOVE VALIDATOR before it deletes local state.
```
curl -fsSL https://shielded-vote.nyc3.digitaloceanspaces.com/remove-validator.sh | bash
```
- Removes svoted and svoted-join services when present.
- Deletes ${SVOTE_HOME:-$HOME/.svoted} and local join binaries under ${SVOTE_INSTALL_DIR:-$HOME/.local/bin}.
- Backs up and removes generated Caddy config only when it clearly belongs to this validator.
Remove Published References

Remove this host's public helper URL from vote_servers[]. Otherwise clients may keep attempting to submit shares to a server that no longer exists. Edit voting config.

Stop And Remove Services

Run the Linux block for systemd hosts. The launchd block is only for macOS development validators.

set -euo pipefail

if command -v systemctl >/dev/null 2>&1; then
  sudo systemctl stop svoted-join svoted 2>/dev/null || true
  sudo systemctl disable svoted-join svoted 2>/dev/null || true
  sudo rm -f /etc/systemd/system/svoted-join.service /etc/systemd/system/svoted.service
  sudo rm -f /etc/default/svoted-join /etc/default/svoted
  sudo systemctl daemon-reload
  sudo systemctl reset-failed svoted svoted-join 2>/dev/null || true
fi

if command -v launchctl >/dev/null 2>&1; then
  launchctl bootout "gui/$(id -u)/com.shielded-vote.join" 2>/dev/null || true
  launchctl bootout "gui/$(id -u)/com.shielded-vote.validator" 2>/dev/null || true
  launchctl bootout "gui/$(id -u)/com.shielded-vote.caddy" 2>/dev/null || true
  rm -f "$HOME/Library/LaunchAgents/com.shielded-vote.join.plist"
  rm -f "$HOME/Library/LaunchAgents/com.shielded-vote.validator.plist"
  rm -f "$HOME/Library/LaunchAgents/com.shielded-vote.caddy.plist"
fi

Delete Local Validator State

This is the destructive part. Confirm the home and install directory before running it, especially on hosts that also have a source checkout.

HOME_DIR="${SVOTE_HOME:-$HOME/.svoted}"
INSTALL_DIR="${SVOTE_INSTALL_DIR:-$HOME/.local/bin}"

rm -rf "$HOME_DIR"
rm -f "$INSTALL_DIR/svoted" "$INSTALL_DIR/create-val-tx"
rm -f "$INSTALL_DIR/join-loop.sh" "$INSTALL_DIR/svoted-wrapper.sh"

Remove Dedicated Caddy Config

Only run this if the Caddyfile was created solely for this validator. Leave shared Caddy configs in place and remove only the validator site's reverse proxy block.

CADDYFILE="/etc/caddy/Caddyfile"
if [ -f "$CADDYFILE" ] && grep -Eq 'reverse_proxy[[:space:]]+(localhost|127[.]0[.]0[.]1):1317' "$CADDYFILE"; then
  sudo cp "$CADDYFILE" "${CADDYFILE}.before-validator-remove.$(date -u +%Y%m%dT%H%M%SZ)"
  sudo rm -f "$CADDYFILE"
  sudo systemctl stop caddy 2>/dev/null || true
  sudo systemctl disable caddy 2>/dev/null || true
fi

Validator Setup

Fresh Join

Provision The Validator Host

Run Fresh Join

Publish The Vote Server URL

Back Up Validator Identity

Install Source Build Requirements

Build The Active Chain Version

Initialize State And Restore Snapshot

Generate Keys And Configure The Node

Expose HTTPS To The Helper API

Register For Funding Approval

Install Cosmovisor

Install The Wrapper Service

Verify, Publish, And Back Up