Full Node Installation

This page covers deployment of a non-validator c8ntinuum ctmd node with the deploy.sh lifecycle script. For hosted deployment scripts and peer-list resources, see Deployment Scripts. Validator nodes need dedicated signing-key, TMKMS, sentry, and double-sign protection procedures.

Network defaults

Use this table as an operator quick reference. For the canonical network records, see Network Information - Mainnet Beta and Network Information - Testnet.

Item	Mainnet	Testnet
Cosmos chain ID	`c8ntinuum_8-1`	`c8ntinuum_8888-1`
EVM chain ID	`8`	`8888`
Native currency	`CTM`	`tCTM`
Public EVM RPC	`https://public-evm-rpc.c8ntinuum.com`	`https://public-testnet-evm.c8ntinuum.link`
Public CometBFT RPC	`https://public-comet-rpc.c8ntinuum.com`	`https://public-testnet-comet.c8ntinuum.link`
Genesis URL	`https://resources.c8ntinuum.io/mainnet/genesis.json`	`https://resources.c8ntinuum.io/testnet/genesis.json`
Genesis SHA-256	`939cd10fe450f6826894f0d76e82ed5e90845d5f60aaae92f577cf50b83bb474`	`f8b98ca1e364026eae17ff15ac133ac8c15fa6864a7e675e77642e8172f7943b`
Peers URL	`https://resources.c8ntinuum.io/peers.json`	Same schema, selected by chain ID

Operating model

OS	Node home	Process model
Linux	`/var/lib/ctmd`	`systemd`, via `ctmd.service`
macOS	`$HOME/.ctmd`	`deploy.sh start` background process with PID/log files

On Linux, deploy.sh install creates a ctmd service user/group, installs a hardened ctmd.service, enables the service, and leaves it stopped until you run deploy.sh state-sync or deploy.sh start. On macOS, it installs the binary and bootstraps the user-managed $HOME/.ctmd home without installing a service.

Recommended operational configuration

Use the node profile that matches the workload. A normal application node should prioritize fast bootstrap, protected RPC surfaces, and bounded historical reads. An exchange, custodian, or indexer that must rebuild history from first principles should run archive infrastructure or consume a dedicated indexer.

Workload	Recommended node shape	Data mode	Notes
Wallets and applications	Full node behind a private RPC gateway	State sync bootstrap, default pruning	Best for current blocks, balances, receipts, and recent logs.
Exchange deposits	Full node plus indexed log pipeline	State sync bootstrap plus durable scanner database	Use bounded RPC scans and idempotent crediting. Add archive/indexer access for long backfills.
Complete historical replay	Archive node	Replay from genesis, `pruning = "nothing"`	State sync does not provide pre-snapshot history.
Debug tracing	Archive node with private debug RPC	Replay from genesis, EVM indexer enabled	Keep `debug`, `txpool`, and `personal` off public endpoints.

Recommended baseline:

Install Linux production nodes with deploy.sh install --moniker <your-node-moniker> and manage them with deploy.sh start, deploy.sh stop, and systemd.
Bootstrap new non-archive nodes with State Sync; replay archive nodes from genesis.
Keep RPC, REST, gRPC, WebSocket, and metrics endpoints on localhost or private interfaces unless a reverse proxy enforces TLS, authentication, rate limits, request size limits, and IP allowlists.
Use the default public EVM namespace shape eth,net,web3 for externally exposed RPC. Enable txpool or debug only on private archive or operations nodes.
For archive nodes, follow Archive Data Setup: set pruning = "nothing", keep ABCI responses, enable the transaction index, and enable the EVM indexer.
Monitor local height, catching-up state, peer count, process restarts, disk growth, RPC latency, HTTP 429 rates, and WebSocket reconnect storms.

Deploy script

To install or update ctmd, run the deploy.sh script. You can download and run the script manually:

curl -fsSL https://resources.c8ntinuum.io/deploy.sh -o deploy.sh
chmod +x deploy.sh
sudo ./deploy.sh install --moniker <your-node-moniker>

This download-first flow is the preferred operator path because it gives you a local script to inspect, rerun, and use for lifecycle commands.

Install from release

Recommended Linux install:

sudo ./deploy.sh install --moniker <your-node-moniker>

Recommended macOS install:

./deploy.sh install --moniker <your-node-moniker>

deploy.sh install reads metadata.json, resolves .ctmd.latest_version, selects the current artifact and SHA-256 URL for the host platform, downloads the tarball, verifies SHA-256, and installs the ctmd binary with bundled shared libraries. It then initializes the node home, downloads genesis, repairs chain ID settings, and patches seeds and persistent peers from https://resources.c8ntinuum.io/peers.json. For mainnet, the downloaded and local genesis.json files are verified against metadata.json field mainnet_genesis_sha256. If you pass a non-default --chain-id, the script skips the mainnet SHA-256 check. The installer creates these managed paths:

Path	Purpose
`/opt/ctmd-<version>/bin/ctmd`	Versioned binary
`/opt/ctmd-<version>/lib/`	Bundled shared libraries
`/opt/ctmd`	Symlink to the active version
`/usr/local/bin/ctmd`	Symlink to the active binary
`/etc/systemd/system/ctmd.service`	Linux systemd unit
`/var/lib/ctmd/`	Linux node home
`/var/cache/ctmd/`	Linux release download cache
`$HOME/.ctmd/releases/ctmd-<version>/`	macOS versioned install
`$HOME/.ctmd/current`	macOS symlink to the active version
`$HOME/.ctmd/bin/ctmd`	macOS CLI symlink
`$HOME/.ctmd/cache/downloads/`	macOS release download cache

Linux service unit

deploy.sh install generates /etc/systemd/system/ctmd.service. The file carries a do not edit header, and both install and state-sync rewrite it, so local changes belong in a drop-in:

sudo systemctl edit ctmd.service
sudo systemctl restart ctmd.service

systemctl edit writes /etc/systemd/system/ctmd.service.d/override.conf and reloads systemd; a drop-in you place by hand needs systemctl daemon-reload. Drop-ins survive reinstall and state sync, but deploy.sh reset deletes the unit and the entire ctmd.service.d directory, so keep overrides in configuration management rather than only on the host. Read the unit on the host you are working on rather than from documentation:

systemctl cat ctmd.service

A host built by hand from a flat /usr/local install carries a different unit at the same path: a non-versioned LD_LIBRARY_PATH, and a real binary at /usr/local/bin/ctmd instead of a symlink. Use one deployment model per host and do not mix them. deploy.sh start and deploy.sh stop drive this unit through systemctl. Logs go to the journal under the ctmd-node syslog identifier. The fields that matter to an operator:

Field	Value	Implication
`ExecStart`	`/usr/local/bin/ctmd start --home /var/lib/ctmd`	Runs through the CLI symlink, which points at the active `/opt/ctmd` install. Repointing the active install takes effect on the next restart, with no unit edit and no `daemon-reload`.
`User` / `Group`	`ctmd` / `ctmd`	Unprivileged system account created by `install`. `install` and `state-sync` set ownership across the node home; anything you copy in by hand, such as a restored `data/` directory, must be owned by `ctmd:ctmd`.
`Environment=LD_LIBRARY_PATH`	`/opt/ctmd/lib`	Bundled libraries resolve through the active symlink rather than the `ldconfig` cache or the binary RPATH, so the binary and its libraries always move together.
`Environment=TMPDIR`	`/var/lib/ctmd/tmp`	`ProtectSystem=strict` makes `/tmp` read-only for the service, and CometBFT writes state-sync chunks through the Go temp directory. `install` creates this directory owned by `ctmd` with mode `0700`; state sync fails if it is missing or not writable.
`Restart` / `RestartSec`	`on-failure` / `10s`	A crash restarts after ten seconds. A clean `deploy.sh stop` or `systemctl stop` stays stopped.
`KillSignal` / `TimeoutStopSec`	`SIGINT` / `600`	`SIGINT` is the clean CometBFT shutdown, and a busy node can take minutes to close its database. Do not shorten the timeout: an earlier `SIGKILL` lands mid-write.
`LimitNOFILE`	`1000000`	Headroom for database file handles and peer sockets. Do not lower it in a drop-in.
`TasksMax`	`infinity`	Removes the default per-unit task cap of roughly 15% of the system maximum, which otherwise limits a busy node unexpectedly.

Two hardening settings are load-bearing. CapabilityBoundingSet= and AmbientCapabilities= are both empty, so the service runs with no capabilities. That is correct only while every listener binds above 1024, as the Ports table below shows. If you move a listener below 1024, add CAP_NET_BIND_SERVICE to both directives in a drop-in; setting one without the other still fails the bind. Prefer a reverse proxy or a firewall redirect over lowering the node’s own bind ports. MemoryDenyWriteExecute must stay no, because libwasmvm JIT-compiles CosmWasm contracts and needs writable and executable pages; setting it to yes crashes the node on contract execution. macOS installs no service. deploy.sh start runs ctmd in the background under your own user, records the PID in $HOME/.ctmd/ctmd.pid, and writes $HOME/.ctmd/node.log; deploy.sh stop sends SIGINT to that PID. There is no unit, no drop-in, and no journal. To return a host to a previously installed version, repoint the active symlink as described in Rollback. The unit does not change, so no daemon-reload is needed.

Build from source

If you are building locally instead of using a release, follow Build the Node, then verify the binary:

ctmd version
ctmd version --long | grep -i rocksdb

Start sync

State sync is recommended for new nodes because it avoids replaying from genesis:

sudo ./deploy.sh state-sync

On macOS:

./deploy.sh state-sync

To replay from genesis instead:

sudo ./deploy.sh start
sudo journalctl -u ctmd.service -f

On macOS:

./deploy.sh start
tail -f "$HOME/.ctmd/node.log"

Ports

Port	Service	Exposure
`26656/tcp`	P2P	Public or peer-restricted
`26657/tcp`	CometBFT RPC	Localhost or reverse proxy only
`1317/tcp`	Cosmos REST/LCD	Localhost or reverse proxy only
`9090/tcp`	gRPC	Localhost or reverse proxy only
`8545/tcp`	EVM JSON-RPC HTTP	Localhost or reverse proxy only
`8546/tcp`	EVM JSON-RPC WebSocket	Localhost or reverse proxy only
`26660/tcp`	CometBFT Prometheus metrics	Firewall-restricted
`6065/tcp`	EVM JSON-RPC metrics	Firewall-restricted

Do not expose RPC, REST, gRPC, or EVM JSON-RPC directly to the public internet without a reverse proxy, firewall, and rate limiting.

Health checks

Check local status:

curl -s http://127.0.0.1:26657/status | jq

Check install and sync status:

./deploy.sh status

status reports the active install, binary version, node home, service state when present, latest height, catching-up state, and peer count.

Monitoring

Enable CometBFT metrics in config.toml:

[instrumentation]
prometheus = true
prometheus_listen_addr = "127.0.0.1:26660"
namespace = "ctm"

Optional EVM JSON-RPC metrics require --metrics on startup and this app config:

[json-rpc]
metrics-address = "127.0.0.1:6065"

Scrape http://127.0.0.1:26660/metrics for CometBFT metrics and http://127.0.0.1:6065/debug/metrics/prometheus for EVM JSON-RPC metrics. Run node_exporter alongside ctmd for disk, CPU, memory, and network metrics.

Common recovery

Use the managed lifecycle commands for normal start, stop, and inspection:

sudo ./deploy.sh stop
sudo ./deploy.sh start
./deploy.sh status

For a clean reinstall, use the destructive reset command:

sudo ./deploy.sh reset

reset deletes the managed install, node home, service, cache, and Linux system user/group so a later install --moniker <name> can start from scratch. Do not run it unless you intend to delete local chain data and key material in the managed node home. On macOS:

./deploy.sh reset

Getting Started

Operations

Advanced

Network defaults

Operating model

Recommended operational configuration

Deploy script

Install from release

Linux service unit

Build from source

Start sync

Ports

Health checks

Monitoring

Common recovery

​Network defaults

​Operating model

​Recommended operational configuration

​Deploy script

​Install from release

​Linux service unit

​Build from source

​Start sync

​Ports

​Health checks

​Monitoring

​Common recovery

Network defaults

Operating model

Recommended operational configuration

Deploy script

Install from release

Linux service unit

Build from source

Start sync

Ports

Health checks

Monitoring

Common recovery