Setting up a node

This page explains what a DogecoinArcade node is made of, what the installer does, and how to do the same thing by hand. If you just want a working node, the installer is the quickest route; the manual steps are here so you can see exactly what ends up on your machine, or reproduce it on a system the installer does not handle.

A DogecoinArcade node is three things running on one machine:

Pepecoin is a Dogecoin Core fork (Scrypt proof of work, AuxPoW merged mining since block 42,000). The protocol DogecoinArcade uses is identical on Dogecoin, so the installer can set up a Dogecoin node instead of, or as well as, a Pepecoin one. Everything below uses Pepecoin; the Dogecoin differences are listed at the end.

``bash curl -O https://dogecoinarcade.com/install.py python3 install.py ``

Check the installer before you run it: the site's homepage publishes the expected sha256sum install.py value next to the command.

Requirements: Python 3.10 or newer (3.12 is what gets tested), gpg for the signature check (strongly recommended), and git if you have it (otherwise the installer fetches a source archive instead).

When it finishes:

`` Start it with: dogecoinarcade Then open: http://127.0.0.1:8420 ``

Installer options

After installation, dogecoinarcade-update (in ~/.local/bin) does the same as --update; it also accepts --dry-run and --check.

Platform support

1. Checks the machine — operating system, architecture, Python version. 2. Downloads Pepecoin Core for your platform from the official GitHub release, unless a Pepecoin Core is already installed (then it is left alone; --force-core overrides that). 3. Verifies it — SHA-256 against the release's SHA256SUMS.asc and against a hash pinned inside the installer, then the GPG signature on SHA256SUMS.asc. It stops on any mismatch. 4. Installs the binaries (pepecoind, pepecoin-cli, pepecoin-tx) into ~/.local/bin. No root needed. 5. Writes two configs: mainnet and testnet. An existing config is never overwritten. 6. Registers both nodes as user services that start at login and keep running after logout. 7. Installs DogecoinArcade into its own virtual environment under ~/.dogecoinarcade. 8. Fetches the latest index bootstrap for each chain, so a new node starts near the chain tip instead of indexing from block zero. 9. Registers the web interface as a user service, writes the dogecoinarcade launcher, adds ~/.local/bin to your PATH if needed, and opens the browser.

The nodes still have to sync their block chains after installation. Testnet is small; mainnet is larger. The application shows progress while they do.

The steps below reproduce the installer on Linux with systemd.

1. Download and verify Pepecoin Core

```bash mkdir -p ~/arcade-install && cd ~/arcade-install BASE=https://github.com/pepecoinppc/pepecoin/releases/download/v1.1.0 curl -LO $BASE/pepecoin-1.1.0-x86_64-linux-gnu.tar.gz # pick your architecture curl -LO $BASE/SHA256SUMS.asc

sha256sum pepecoin-1.1.0-x86_64-linux-gnu.tar.gz grep pepecoin-1.1.0-x86_64-linux-gnu.tar.gz SHA256SUMS.asc ```

The two hashes must be identical. The installer additionally pins these hashes:

Then check the signature. The signing key is not on public keyservers, so it comes from the Pepecoin source tree at the release tag:

``bash curl -L -o signer.pgp \ https://raw.githubusercontent.com/pepecoinppc/pepecoin/v1.1.0/contrib/gitian-keys/david2278-key.pgp export GNUPGHOME=$(mktemp -d) gpg --batch --import signer.pgp gpg --batch --verify SHA256SUMS.asc ``

Expect Good signature from key 18250EC9 2E527E97 23E49116 FD415169 D2691927. Stop if either check fails.

Two things to be aware of:

• The signing key expired on 2026-01-02. The v1.1.0 signature was made on 2024-12-16, while the key was valid, so it still stands; expiry only prevents new signatures. gpg will mention the expiry.
• Trust is single-channel. The tarball, checksums, signature and signing key all come from the same GitHub organisation, and pepecoin.com links back to the same releases. A compromise there would defeat every check at once. If that matters to you, build from source and compare: the release binary reports v1.1.0.0-4fb5a0cd9, and the v1.1.0 tag is commit 4fb5a0cd930c0df82c88292e973a7b7cfa06c4e8.

2. Install the binaries

``bash tar xzf pepecoin-1.1.0-x86_64-linux-gnu.tar.gz mkdir -p ~/.local/bin install -m 0755 pepecoin-1.1.0/bin/{pepecoind,pepecoin-cli,pepecoin-tx} ~/.local/bin/ ``

pepecoin-qt and the test binary are not needed on a node.

3. Write the configs

Mainnet goes in ~/.pepecoin/pepecoin.conf:

```ini server=1 txindex=1 prune=0

rpcbind=127.0.0.1 rpcallowip=127.0.0.1

dbcache=512

zmqpubhashblock=tcp://127.0.0.1:28332 zmqpubrawblock=tcp://127.0.0.1:28333 zmqpubrawtx=tcp://127.0.0.1:28335 ```

Testnet goes in ~/.pepecoin-testnet/pepecoin.conf: the same file with testnet=1 added and the ZMQ ports moved to 28432 / 28433 / 28435.

Make both files mode 0600.

4. Register the nodes as user services

Create ~/.config/systemd/user/pepecoind-mainnet.service:

```ini [Unit] Description=Pepecoin mainnet Core for DogecoinArcade After=network-online.target Wants=network-online.target

[Service] Type=simple ExecStart=%h/.local/bin/pepecoind -datadir=%h/.pepecoin Restart=always RestartSec=5 TimeoutStopSec=600 RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6 AF_NETLINK NoNewPrivileges=true PrivateTmp=true ProtectSystem=full ProtectKernelTunables=true ProtectControlGroups=true RestrictRealtime=true

[Install] WantedBy=default.target ```

and pepecoind-testnet.service, identical except for -datadir=%h/.pepecoin-testnet. Then:

``bash systemctl --user daemon-reload systemctl --user enable --now pepecoind-mainnet.service pepecoind-testnet.service loginctl enable-linger "$USER" # keep them running after you log out (may need sudo) ``

Why the unit looks like this:

• Type=simple, foreground. This codebase has no -daemonwait, so Type=forking would race against the PID file.
• Restart=always. The application restores a wallet by shutting the node down cleanly and swapping wallet.dat; the node has to come back afterwards. An explicit systemctl stop is still honoured.
• AF_NETLINK must be allowed. libzmq opens a netlink socket to enumerate interfaces; without it the daemon aborts at startup.
• It runs as you. .cookie is always written with mode 0600, so cookie authentication only works when the application runs as the same user as the daemon.

5. Install the application

``bash git clone https://dogecoinarcade.com/repo ~/.dogecoinarcade/src python3 -m venv ~/.dogecoinarcade/venv ~/.dogecoinarcade/venv/bin/pip install --upgrade pip ~/.dogecoinarcade/venv/bin/pip install --upgrade "$HOME/.dogecoinarcade/src[web]" ~/.dogecoinarcade/venv/bin/python -c "import arcade" # should print nothing ``

Without git, download https://dogecoinarcade.com/source.tar.gz, check it against https://dogecoinarcade.com/source.tar.gz.sha256, and unpack it into ~/.dogecoinarcade/src. https://dogecoinarcade.com/source.rev names the revision it contains.

A dedicated virtual environment keeps the pinned dependencies away from the rest of your system.

6. Fetch the index bootstrap

The application keeps its own index of each chain in ~/.dogecoinarcade/<test|main>-ledger.sqlite. Building it from block zero is slow, so a live node publishes a recent copy. For each of test and main, and only if you have no index yet:

``bash NET=main # then repeat with NET=test curl -O https://app.dogecoinarcade.com/bootstrap/$NET.json curl -O https://app.dogecoinarcade.com/bootstrap/$NET.sqlite.gz cat $NET.json # shows bytes, sha256 and height stat -c %s $NET.sqlite.gz # must equal "bytes" sha256sum $NET.sqlite.gz # must equal "sha256" gunzip -c $NET.sqlite.gz > ~/.dogecoinarcade/$NET-ledger.sqlite.partial mv ~/.dogecoinarcade/$NET-ledger.sqlite.partial ~/.dogecoinarcade/$NET-ledger.sqlite ``

The node carries on indexing from the bootstrap's height. An existing index is never replaced. If you skip this step (or the installer's --no-bootstrap), the node builds its index from the chain itself, which just takes longer.

7. Run the web interface

Create ~/.config/systemd/user/arcade-web.service:

```ini [Unit] Description=DogecoinArcade web interface After=network-online.target Wants=network-online.target

[Service] Type=simple ExecStart=%h/.dogecoinarcade/venv/bin/arcade-web Restart=always RestartSec=10 RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6 AF_NETLINK NoNewPrivileges=true PrivateTmp=true

[Install] WantedBy=default.target ```

``bash systemctl --user daemon-reload systemctl --user enable --now arcade-web.service ``

Then open http://127.0.0.1:8420.

arcade-web binds to 127.0.0.1 by default, on purpose: whoever can reach the port controls the node's wallet. See remote-access.md for reaching it from elsewhere.

```bash systemctl --user status pepecoind-mainnet pepecoind-testnet arcade-web systemctl --user restart pepecoind-mainnet journalctl --user -u pepecoind-mainnet -f tail -f ~/.pepecoin/debug.log

pepecoin-cli -datadir=$HOME/.pepecoin getblockchaininfo pepecoin-cli -datadir=$HOME/.pepecoin-testnet getblockchaininfo ```

Game rooms (arcade.realtime) run over a mesh of arcade nodes linked to each other directly, with no server in between. It is on by default, and needs nothing set up to work: a node dials out to the nodes announced on the chain.

Letting other nodes reach yours helps the mesh and makes your node a place others can join through. Forward TCP 8421 on your router to the machine running the node, and open it in its firewall:

``bash sudo ufw allow 8421/tcp ``

That is all. A listening node works out its own public address from what its Pepecoin peers see, dials itself there to check it really leads back, and then announces it on the chain. It does that again whenever the address changes, and once a day to stay fresh. It looks every ten minutes. Nothing is announced while the port is not forwarded, and the node still plays by dialling out. An announcement is a small transaction paid from the node's fee address.

STUN for fast games. Fast games connect players' browsers directly to each other (the fast lane, see the multiplayer guide). Before they can, each browser asks a STUN server what address the internet sees it at. Every node runs one on UDP 3478. Another node checks that it can reach yours before it is offered to any browser, so forwarding the port is optional:

``bash sudo ufw allow 3478/udp ``

A STUN server only tells a browser its own address. It carries no game traffic and keeps nothing. When no node's STUN is known, browsers use a public one (Cloudflare's). To turn that off, set "realtime_public_stun": false in the node's settings.

The web interface prints the node's mesh id when it starts, and says whether it is listening.

Checked against pepecoind -help for v1.1.0:

If you prefer a system-wide node (binaries in /usr/local/bin, config in /etc/pepecoin/pepecoin.conf, datadir /var/lib/pepecoind, a dedicated pepecoin user and a hardened system unit), note that cookie authentication will not work for the application: .cookie is always 0600, and no group membership, -rpccookiefile path or ACL shares it across users. Use rpcauth in the node's config and give the application a config with rpcuser / rpcpassword (arcade-web --ledger-conf ... / --msg-conf ...).

When generating the rpcauth line yourself, the HMAC uses the salt as the raw ASCII of the hex string, not decoded hex. Getting this wrong gives a silent authentication failure.

The installer always installs both coins, with no question: Pepecoin Core (a mainnet node and a testnet node) and Dogecoin Core (a mainnet node only). They are the arcade's three networks: testnet PEP, mainnet PEP and DOGE. There is no Dogecoin testnet node; the arcade's testnet is Pepecoin's.

The Dogecoin mainnet chain is large: its first sync takes much longer than Pepecoin's, and the arcade shows its progress.

A node you already run

If a node's config file already exists, the installer adds the settings the arcade needs that it does not have (server, txindex, rpcbind, rpcallowip, the ZMQ lines), in one block marked # --- added by the DogecoinArcade installer ---. Nothing you wrote is changed or removed: a setting you already have, whatever its value, stays yours. A running node picks the additions up when it restarts.

The one setting it will not add for you is txindex=1 on a node that already holds blocks: switching it on there stops the node until it is restarted once with -reindex, a full rebuild. The installer says so; add it yourself when you are ready for that.