This page explains what changes for someone who runs the community node (4.2.532-community.N) in
place of the official 4.2.532 node from CREDITSCOM. It covers behaviour, not code. For the full
list of changes, pull request by pull request, see CHANGES.md.
- Network. The protocol version (532), the block format and the hashes are unchanged, and so are the consensus rules, except for the cases listed under "Consensus fixes" below, which only change what a node does when a round ends in conflict. A community node syncs and takes part in consensus alongside official nodes.
- Configuration. The official
config.iniworks unchanged. Without a[storage]section the node is a full node on BerkeleyDB, like the official one. It opens the samedb/folder and converts nothing. - Upgrading. You can upgrade a folder of the official node by replacing the binaries, and go
back to the official binaries later. Both directions are tested in CI on mainnet data
(
upgrade-compat). Going back works only on a full BerkeleyDB folder: the official node reads only BerkeleyDB, and needs every block. - Keys, ports and the Thrift API. These are unchanged. The API changes: when blocks are
pruned,
TransactionsListGetskips them (see "Pruned storage" below), and the diagnostic API returns two more optional fields (see "Network identity in the diagnostic API" below).
There are new keys in the [storage] section of config.ini. See storage.md for
each key and its default.
| Key | What it does |
|---|---|
db_backend |
Chooses the block database: berkeleydb (the default, the official format), lmdb or rocksdb. RocksDB is about a third of the BerkeleyDB size on mainnet. |
prune_keep_blocks |
Pruned storage: the node keeps only the latest blocks and removes older ones at each periodic checkpoint. Pruned storage runs on LMDB. |
async_write_queue_size, write_batch_size, rocksdb_block_cache_mb, rocksdb_memtable_mb |
Tune the database writer and RocksDB. |
backfill, backfill_batch, backfill_rate, backfill_store_per_turn, backfill_turn_budget_ms, backfill_idle_turn_budget_ms, backfill_verify_threads |
Backward sync: a full node whose oldest block is above block 0 (started from a snapshot on lmdb or rocksdb, or switched from pruned to full) fetches the older blocks from its neighbours in the background, with the existing block requests, checks each against the chain's hashes and its signatures and stores it without applying it; the API serves each block and history as it arrives. On by default; backfill=off keeps only the snapshot's blocks. |
The node converts an existing database to another backend in place.
--convert-dbconverts, then starts the node.--convert-onlyconverts, then exits.--convert-batch Nsets how many blocks go in each batch.
The conversion is verified batch by batch. If it is interrupted (by Ctrl-C, a kill or a power cut), it resumes at the next start. Checkpoints and the transaction index stay valid, so the node quick-starts after a conversion.
What an operator sees and sets is in snapshots.md.
--export-snapshot <dir>, on a stopped node of any backend, pruned or full, builds a snapshot of its latest periodic checkpoint: the checkpoint files, the blocks before it as a hash chain ending at the checkpoint's block, compressed, with a SHA-256 for every file and every 512 KiB piece, in asnapshot.jsonsigned with the node's key (the checkpoint carries the contract states at its block).--download-snapshot [url]downloads the snapshot published on GitHub (or the one aturl) withcurl, checks it and restores it as--import-snapshotdoes; run by hand or by the Docker entrypoint, never by a normal start.--import-snapshot <snapshot.json>restores such a snapshot into an empty database of the configured backend (LMDB or RocksDB). Every file is checked against the manifest and every block before it is written: its signatures against its confidants, the confirmations of the round before, and the hash chain to the declared block; the checkpoint must declare the manifest's state digest. Anything wrong leaves nothing behind. The node then quick-starts from that checkpoint.- The
[snapshot]section ofconfig.iniholds the settings of p2p snapshot sharing (snapshots served by community nodes to their neighbours and fetched from them at a first start:serve,serve_rate_kbps,serve_max_peers,snapshot_blocks,fetch,fetch_wait,fetch_fallback,min_sources,sources,sources_file,fetch_rate_kbps). A key that is not one of these is logged and ignored. - Serving snapshots to the neighbours. With
[snapshot] serve=onthe node builds the snapshot of each periodic checkpoint intosnapshot/<block>/at low priority and answers the snapshot requests of its p2p neighbours while it is synced with the network, withinserve_rate_kbps(KB/s, all peers together; half for one peer),serve_max_peerspeers within 30 s, and half of that while it is a confidant or the writer. It announces it in its p2p host data at start, with its community version; community peers refresh that value from the node's answers to their pings, so a restart with anotherservevalue is seen within about a minute (official peers keep the value they first saw until the node leaves their routing table). Official nodes neither see nor answer these messages. - A first start fetches a snapshot from the network. A node whose
db/holds no database, with no checkpoint inqs/,db_backendlmdborrocksdbandfetch=auto(the default), starts its p2p transport without opening the chain and looks for neighbours that serve snapshots (SNAPSHOT: empty database: looking for snapshots on the network). Oncemin_sourcessources in different /24 (or /48) networks, or keys listed insources, agree on a snapshot, it downloads it, imports it and quick-starts from it; meanwhile it processes no other message. Without agreement withinfetch_waitseconds it syncs from block 0 (fetch_fallback=sync) or keeps waiting (wait); the log line names--download-snapshotas the faster way. A BerkeleyDB node never fetches. The sources used are listed insnapshot.sources.json. - Private and genesis networks set
fetch=off. Every node of a network that starts from block 0 starts on an empty database: withfetch=auto, LMDB and RocksDB nodes would waitfetch_waitfor snapshots nobody has. - The restored state is checked at start. When
snapshot.jsonis present (written by--import-snapshotor by the fetch) andsnapshot.verifiedis not, the node compares the digest of the state its quick start loaded with the manifest's. It writessnapshot.verified, orsnapshot.mismatchand stops with exit code 4; it refuses to start whilesnapshot.mismatchexists. An import interrupted by a kill leavesdb/.importing; the next start removes what that import wrote before it looks atdb/.
GetNodeInfo of the diagnostic API ([api] diag_port) returns two optional fields in NodeInfo,
from the Thrift definitions of the fork
CreditsCommunity/thrift-interface-definitions
(branch community/network-id):
| Field | Value |
|---|---|
9: optional i64 networkUuid |
The chain identifier: the first 8 bytes of the hash of block 1, read as a little-endian unsigned 64-bit number (BlockChain::uuid()). It is the same on every node of a network, so a client such as a wallet can tell mainnet from a test network. Pruned nodes and nodes started from a snapshot know it too (it is in the checkpoint). Left out while the node does not know it yet (an empty database before block 1). Thrift has no unsigned type: the same 64 bits travel as a signed number, so mainnet, 11024959585341937636, arrives as -7421784488367613980; add 2^64 to a negative value (or mask with 0xFFFFFFFFFFFFFFFF) to get the unsigned one. |
10: optional string communityVersion |
The package version, the first line of the VERSION file, for example 4.2.532-community.18.2. Without a VERSION file it is 4.2.<protocol>.<minor>. Always set by the community node. |
The official node sets neither field, and clients built from the official definitions ignore them,
so a client can detect a community node by the presence of communityVersion. A local clone made
before this change needs git submodule sync once, since the submodule now points to the fork.
[api] tokens_cache=true turns on the token cache behind the Token* API methods in any build.
The official node has it only in its monitor and wallet builds. The cache follows tokens of every
standard, including v1/v2 tokens whose amounts are BigDecimals, and it skips failed calls. It is
rebuilt from the chain when the checkpoint holds none. See tokens.md.
-
A banner names the release. At start the console and the log show the CREDITS logo with "community" under it, then the release (
4.2.532-community.Nfrom theVERSIONfile), the protocol, the build commit, the storage (pruned or full, database), whether snapshots are served, and for a full node whether it backfills.[params] banner=offkeeps the text lines only, for log collectors. -
Database check. Before opening the block database, the node looks at
db/. It writes the backend's name indb/.backend, and holdsdb/.lockso that two node processes cannot use the same folder. It stops with exit code 3, changing nothing, in these cases:db/holds a database of another backend thanconfig.iniasks for, and no conversion was requested;db/holds two databases with blocks;- another process holds the folder.
The message says what to do. From a terminal, the node asks whether to convert instead.
-
Checkpoints. The checkpoints used for a quick start (
qs/) are checked against the stored chain before they load. A checkpoint that does not match the blocks on disk is not loaded. If it is ahead of them, which can happen after a crash between saving a checkpoint and writing its block, it is moved aside toqs/<version>.badand the next start uses an older checkpoint, instead of failing the same way every time. -
No slow start for a lost index. The official node falls back to a slow start, replaying every block from 0, whenever the caches are inconsistent. The community node repairs the usual causes instead:
- it rebuilds the transaction index (
caches/indexdb) from the stored blocks after a quick start; - it rebuilds the block hash databases (
blockHashes: rebuilding from the stored blocks ...) when they fail their check.
- it rebuilds the transaction index (
-
Bootstrap with more than 8 confidants. The official node gives a bootstrap round table a weight that fits in 8 bits and silently drops tables of 9 or more confidants, so a network whose initial confidants (or the bootstrap nodes set by special order 2) are 9 or more never starts or restarts. The community node accepts tables of up to 25 confidants (
MaxTrustedNodes). Up to 8 it gives exactly the official weights, so both pick the same table when a stalled network starts again; a dropped table is now logged. -
Bootstrap tables are checked against the node's own state. A bootstrap round table is taken only for a round next to the node's own (from its last block to its round + 2), and, unless it is signed with the blockchain key, only once the node's own round has lasted at least half of
round_elapse_time(a node younger thanround_elapse_time, or already in a bootstrap round, takes it as before). The tables honest nodes send pass in the cases a mixed network relies on, so it makes the same choices; a node that joined the stalled round late, or that is several blocks behind and has not learned the round yet, takes the next table instead. A bootstrap through the diag API must name a round within two of what the nodes know (their last block + 1, as the sending node uses when it raises the round). -
State kept across a quick start. Pending consensus-settings changes, special orders and deployed smart contracts survive a quick start. The official node can lose them, or apply them differently, after a quick start.
-
Wallet state digest. Every 1000 blocks the log has a line
STATE DIGEST #<sequence> <hex>. It is a digest of all wallet state, so nodes, builds and backends can be compared: two nodes that agree on the chain must print the same digest at the same sequence. Every checkpoint saves the digest of the state it holds, with a hash of the consensus settings, asqs/<sequence>/state_digest.bin, and logs it (STATE DIGEST #<sequence> ... checkpoint). A quick start recomputes it from the loaded caches, logs... checkpoint loaded, and moves a checkpoint whose caches do not match it aside toqs/<sequence>.bad. -
Stage-3 diagnostics. A trusted node logs at info level what it signed in stage 3 (sequence, previous hash, timestamp, reward, a hash of the transactions and fees, the three signed hashes), why a peer's stage 3 failed (another block/round hash, or a key/message mismatch), the agree/disagree split among the confidants, and which keys a round package gray-lists, with
OWN KEYwhen this node is one of them. Logging only: see consensus-diagnostics.md to tell from these lines which input differed. -
Stopping on errors. Some errors that the official node can survive in an inconsistent state now stop the node, and are logged with
cserror:- a block that cannot be stored;
- a block that fails to apply to the caches;
- a BerkeleyDB environment that needs recovery.
The caches are not saved in these cases, so the next start rebuilds them from the database. Run the node under a supervisor (systemd, Docker
restart:) so that it restarts. -
Full disk. On RocksDB a full disk no longer blocks the writer: the node keeps the blocks in memory and retries.
-
Pruned storage. A pruned node answers NoSuchBlocks for blocks it has pruned, so a peer asks another node for them.
TransactionsListGetskips pruned blocks. -
Contract states while syncing. Blocks carry only the hash of a contract's new state. The official node, when it syncs, re-executes the calls to rebuild the states; for some contracts this is not reproducible (a game that reads its own balance sees it after the block's payout), the state stays out of date, and the fee of a later payout was charged to an earlier caller, so official nodes disagree among themselves on such callers' balances. The community node:
- charges a payout's fee as the nodes that executed the contract do (see "Consensus fixes");
- records, for every contract, the call and the hash of the state the chain declares, and once
it is live asks the confidants for every state it holds out of date (at most 16 a round,
then less and less often), taking only the declared one; the log has a line per state received
and a summary (
contract states: N known, S stale, …) when the node becomes live and every 1000 rounds while some remain; [params] sync_contract_execution(defaulttrue):falseskips the re-execution while syncing altogether, and every state comes from the confidants.
-
Contract calls that cannot run are refused.
TransactionFlowchecks the method and the types of the arguments of a contract call against the contract, and refuses a call that no method matches, which would fail on every node with its fee paid (a token amount passed as a string to a method that takes a BigDecimal, or the reverse). See tokens.md. -
Contract results after a quick start. A node that quick-starts from a checkpoint at its last stored block reads no block. The official node then never marks its stored blocks as read, and every contract call sent through its API ends with "Transaction in progress" and no result, even though the network executed the call. The community node marks the blocks as read when it starts running.
These were found by reviewing the official code. None of them changes the blocks or the consensus rules.
- Remote crashes and out-of-bounds reads. Fixed when a peer sends a malformed compressed
region, an empty packet, or a pool whose lengths point past its data. Also fixed: a data race
in
LockFreeChanger. - A size limit on p2p packets. The node runs its own fork of the p2p library
(CreditsCommunity/p2p, from the commit the official node uses). The
first packet of a connection (the registration) may announce at most 64 bytes of data, any
later packet at most 256 MiB, far above any packet the node sends; above that the connection is
closed before anything is allocated, with an error line at most once a minute per address
(
Packet header from <address> announces <n> bytes, above the limit of <limit>: connection dropped (...)). Below the limit the data is read in chunks of 1 MiB, so the memory held follows the bytes actually received, not the size announced. Official nodes allocate whatever size is announced. The fork also shows a peer's latest host data (version, snapshot capability), refreshed from its answers to our pings, instead of the first one seen; passes each received datagram with its own length; and stops its routing table (threads, UDP socket) with the p2p host at exit. - Smart-contract solver. Fixed:
- stale contract locks;
- executor connections lost between calls;
- a race on a contract call's inputs;
- contract states accepted from peers without a request;
- stage-1 messages that arrive early.
- Consensus state after a restart. Fixed:
- the mining and staking flags swapped on restore;
- the rewards of an uncertain block kept when the trusted mask differs;
- the revert of a timed delegation;
- uninitialised consensus settings.
- Encrypted key file. Safer handling of the encrypted key file (atomic re-encryption, no empty
file on failure, clear errors); the file format is unchanged and stays compatible with the
official node. When the node encrypts or re-encrypts
NodePrivate.txt(--encryptkey, the change of password offered at start, a new key at the first start) it writesNodePrivate.txt.tmp, flushes it and renames it over the key file, so a crash or a full disk leaves the previous file, and the log says the write failed instead of reporting success. A failed encryption never writes an empty key file, a key file of an unexpected length stops the node withBad private key file in ... (N bytes)instead of asking for a password, a failed key derivation is an error instead of a crash, and a file used as password is wiped from memory after use.
-
Bounded automatic rollback. When a node is behind and syncs a competing chain that forks below its current head, it rolls back its own blocks down to the fork point before taking the other chain. The official node puts no limit on that depth. The community node stops the automatic rollback once it would unwind more than
max_auto_rollbackof its own confirmed blocks (default 100) below the head it had when the rollback started: it leaves its chain intact, logs a prominent alert and waits for the operator. The bound covers every automatic removal path — the sync fork path, the uncertain-block replacement, the antifork cache and the bad-hash reply — because the depth check lives inside the two functions they all go through. The depth is measured against a fixed reference, so forward progress cannot reset it and a node cannot be made to creep past the limit by alternating removals and appends; the reference is kept inreorg-episode.jsonnext to the database, so a restart does not reset it either. A reorg this deep is a rare event — a deliberate switch to another network, or a rejected one — and the choice is left to a human instead of happening silently. The node keeps running and does not crash-loop. The start-up integrity repair (blocks of the node's own database that fail the hash check, removed when the operator chooses to resolve them) is a local repair, not a reorg, and is not bounded.Before any of this, the competing block itself must be vouched for by authority the node already recognises, or the node does not unwind at all, not even by one block. A competing block that is not a bootstrap block needs round confirmations from a majority of the confidants of the node's own last block, checked as the block verifier checks a block from the network, but more strictly (no one-entry confirmation masks). An honest micro-fork passes, because the honest competing block at the same height was produced by the same elected trusted group. A bootstrap block carries no such confirmations (the verifier accepts it without them, so this check refuses it), and its bootstrap flag alone proves nothing, so it passes only when it is authenticated locally: its own signatures verify and its confidants are exactly those of a round table this node itself accepted in the last few rounds. Otherwise the node keeps its chain and the operator decides. Everything that passes is still subject to the depth bound.
FORK HELD. Whenever the node refuses to unwind (beyond the bound, or a competing block not vouched for), it records the fork in
fork-held.jsonnext to the database — the fork point (the highest of its blocks the other chain can share, with its hash, exact when the competing block names it as its previous block), its head, the refused block, the peer and its announced height, the time and the episode's reference — and reports FORK HELD until the episode ends or the operator decides:| FORK HELDon every round line (R-<n> NORMAL | FORK HELD), a detail line with the two remedies once a minute, and an unhealthy Docker healthcheck. The state clears by itself when the head climbs back above the reference. A competing block not vouched for is refused at once, but reported as FORK HELD only when the head stays at the same block after it (two round starts, or a minute), so a peer on a minority branch cannot make it flap. An unreadable guard file is reported and fails safe (a new rollback episode at the head; FORK HELD kept), the files are written with a flush to the disk, and they are removed when the database is replaced (a new empty database, a snapshot restore). The operator, after checking with other nodes or the monitor, either keeps this chain — adismiss-forkfile next to the database, which the running node picks up within a few seconds: the record keeps that branch (its first known block and the hashes seen since) as dismissed, the node still refuses it but no longer reports it, and a different branch is reported again — or follows the other one:--resolve-fork(no argument) cuts the chain at the recorded fork point, only if the block there is still the recorded one; the node then syncs forward from there. It relaxes nothing else: when the fork point is exact, only the recorded competing block right after it — that very hash — may replace a block the node stored again right after the fork point; nothing is ever unwound to or below the fork point, every other block meets the usual checks, and an unauthenticated offer changes nothing. The approval ends once the node goes on past that height, or a competing block that passes the usual checks is offered there. When the fork point is only an upper bound and the other chain diverges lower, the node reports FORK HELD again with a lower fork point;--set-bc-top <sequence>then cuts by hand at the last common block found with the monitor or other nodes. Both are one-shot and exit; neither advice is ever "restart", since a restart alone changes nothing. See "If your node reports FORK HELD" indocs/quick-start.md.This is a local safety bound only: it changes how far this node unwinds on its own, never what a block contains or what the node accepts in normal operation, so it is invisible to other nodes and a mixed official/community network behaves exactly as before. Two settings tune it, both in
[params]:max_auto_rollback=sets the bound (default 100; 0 removes the depth bound, the authority check stays), andallow_deep_rollback=trueaccepts a deliberate switch: it lifts both the depth bound and the check above, since the other chain's blocks are confirmed by confidants this node does not hold. TheCS_ALLOW_DEEP_ROLLBACKenvironment variable does the same. It is the last resort, after--resolve-forkand--set-bc-top: once one rollback episode has completed with it, the node turns it off for the rest of the run and says so loudly; remove it from the configuration then.After a partition, and a lagging node. When both sides of a split keep producing blocks, each side's blocks are confirmed by its own confidants. On reconnection a node on the shorter side does not follow the longer chain on its own, whatever the depth, because that chain's blocks are not confirmed by any confidants it holds: it keeps its chain, reports FORK HELD and the operator decides. The official node unwinds to the longer chain without asking. A single node or a minority that cannot reach consensus while cut off builds no branch and simply syncs forward when it reconnects. The same holds for a node that lags behind with a divergent last block it never replaced (for example, it missed a bootstrap round): when the network's next block is not confirmed by the confidants of that block, the node waits for the operator instead of unwinding it. This is the deliberate choice of this change;
--resolve-forkis the remedy. The opt-in community bootstrap fallback (PR #188, not merged yet) expects the longer chain to win after a partition; with this change that switch is an operator decision too. -
Two blocks of one round. When a trusted node does not get one stage-2 in time, it fetches it with a request that takes exactly as long as the others wait for its stage-3. Depending on a few milliseconds, some trusted nodes finish the round with every signature while the others retry stage 3 without the late node, and the writer publishes the retried block. The two blocks differ only in the set of real trusted. The official node keeps its own block for good, then no longer matches the following rounds (seen in CI as a network stuck in bootstrap). The community node logs this as a fork and, if it is a trusted node that still holds the block undeferred, takes the writer's block when:
- a majority of all the trusted of the round signed it, checked against the node's own list of the round's trusted, so a minority of dishonest signers can never make it switch;
- the nodes outside that set are too few to form a round on their own block.
Fees and the block reward move to the new set of signers.
-
The official "more signatures" rule works. The official node meant to replace its block by one with more signatures, but the check before the replacement compared the block with itself and always failed. It now works. Residual risk, as in the official design: a package with more signatures that reaches only part of the network would move only that part.
-
Fees of contract payouts. A transaction a contract emits is charged to the contract's latest successful execution in the same block, which is what a node that executed the contract does (it applies every new state of the block before the payouts). A syncing official node whose re-execution failed charges it to an earlier caller instead. This changes, by one fee, the balances such a node computes for those callers, and makes them those of the nodes that took part in the rounds.
-
Known state corrections. The lineage of the published pruned snapshots synced the dice-contract blocks of 2026-06-05 with the official replay rule above. The payout 176760929.2 (block 176,760,929) pays
MooNRor8…the win of its call 176760925.1, whose fee already includes the emitted transaction's fee. The replay of that contract state failed, the staleref_executestill pointed to the previous successful call, by7hWM6wvs…, and the payout's contract-state fee (0.008740234375 CS) was charged to7hWM6wvs…as well: that lineage holds one fee less for7hWM6wvs…than the majority that executed the contract.MooNRor8…was the expected counterpart, but the nodes of the majority report the sameMooNRor8…balance as that lineage (public API of 8 majority and 3 minority nodes at block 187,731,527, 2026-11-10, with7hWM6wvs…one fee apart on the same calls), so there is none to correct.7hWM6wvs…is a confidant in half of the rounds, and every reward split a community node signs for it differs from the majority's by that fee, which puts the node in the stage-3 minority.csnode/statecorrectionkeeps a table of such known differences: the proven wallet, its delta, and optional counterpart adjustments applied in the same step (counterparts are not proven by the reward split; they come from the transaction that caused the difference). An entry applies only on its network (the chain uuid of mainnet, also known to nodes started from a snapshot; never on the test network or private networks) and from the block that caused it (176,760,929). A correction is applied once, at the first block that proves it: the proven wallet is a trusted confidant of the block, staking is on, the block's stored reward split (signed by the majority) differs from the one this node's stakes give, and it is reproduced exactly with the delta applied. If a counterpart's balance is below its adjustment, nothing is applied and a warning is logged: no balance is made negative. A node whose state is already right never applies it, an applied correction is never applied twice, and a block that neither value explains is only logged (rate-limited per entry). The node logs the block that proved the correction and the new balances of every wallet it changed. Rounds where the trusted majority is the uncorrected group may still put a corrected node in the minority: the correction makes the node agree with the network majority, not with every round's trusted majority.
Official nodes on the side that keeps its block behave as before; mixed networks do not fork (CI: equal state digests with official binaries on half of the nodes, and the same share of signed rounds for both).
-
Release packages. Each release has one package for full and pruned storage (until community.13, a full and a pruned package), in these builds:
linux-x64needs glibc 2.38 (Ubuntu 24.04, Debian 13 and later);linux-x64-glibc2.31runs on Ubuntu 20.04, Debian 11 and later;windows-x64(a.zip, Windows 10 and later; startnode.exefrom a terminal in thecsnodefolder) andmacos-arm64(Apple Silicon; clear the download quarantine once withxattr -dr com.apple.quarantine csnode; the node is not signed).
The Linux packages include the JDK of the official release; the Windows and macOS ones include Eclipse Temurin 11 (the official release has no JDK for them), in
jdk/, and theirexecutor_commandpoints at it. Each package includes the community build of the contract executor. -
Checkpoints and snapshots are the same on every system. A Windows or macOS node loads what a Linux node wrote and the other way round: the binary checkpoint files record
longas 8 bytes whatever the system, and the checkpoint's text files are read and written in binary mode. On Linux the files are byte for byte what they were. -
config.iniin the packages. It is the official one, with five changes:[event_report]is commented out (it reports node events to a fixed address);executor_commit_maxaccepts the community executor;compatible_version=true, the default of the node binary (the official file setsfalse): a synced block that fails the node's own transaction check is logged (skip block validation) and stored, instead of stopping the node at it for good. See "Contract states while syncing";sync_contract_execution=true(the default), with a comment;- next to it,
config.pruned.iniis the same file with a[storage]section for pruned storage on LMDB:./node --config-file config.pruned.ini.
The executor listens on 127.0.0.1 only.
-
Known hosts.
known_hosts.txtis refreshed weekly from a verified list of seed nodes. -
Docker image. The image is
ghcr.io/creditscommunity/credits-node(until community.15ghcr.io/enzinobb/credits-node, still updated for a while). By default it runs a pruned node that starts from a snapshot of the chain, published every 12 hours, instead of syncing from block 0. The snapshot's checksum and its state digest are verified before use. A full node on lmdb or rocksdb starts from the snapshot too and fetches the older blocks in the background (CREDITS_BACKFILL=offto keep only the snapshot's blocks); switching from pruned to full is allowed. See packaging/docker/README.md.