Runtime Contract Directory

NiceChunk contracts, live game configuration, and PDA transparency.

This page separates the game client's current runtime configuration from contracts that exist in code but are not referenced by that client configuration. A config omission is not an on-chain disable switch. Players can inspect source code, PDA structures, and public devnet accounts from one page.

Open Directory View Logic Atlas Read Live Flow Browse PDAs GitHub Repo

Network Solana Devnet

The current game runtime points to Solana devnet through mainnet.json. Mainnet finality and live civilization governance are not claimed here.

Runtime State

What the game client is actually configured to use now.

This section reads the public mainnet.json runtime index and separates programs referenced by the current game client from contracts that exist in code. Omission from this file is not an on-chain disable switch.

Contract Logic Atlas

Understand the contracts as a connected trust graph.

Each map shows the actor, program boundary, PDA evidence, and public verification surface. The goal is to explain what the contracts actually protect before a reader opens the code or RPC browser.

PDA Seed Evidence

Follow each public account back to the exact seed family that creates it.

These graphs turn the Rust and SDK seed constants into a reviewer-facing evidence map, so drift in PDA names, signer boundaries, or runtime assumptions is easy to spot.

Instruction Surface Map

Trace every accepted instruction tag to the gate that handles it.

These maps mirror the current Rust process_instruction match arms, including retired and invalid tags, so SDK builders and reviewers can spot stale integration assumptions before they reach chain calls.

CPI Authority Ledger

Audit game-facing cross-program writes by caller, callee tag, signer PDA, and public evidence.

These maps follow the current NiceChunk invoke and invoke_signed sites in Rust, so reviewers can see exactly which program is allowed to mutate another program's state and which PDA proves the write.

Authority & Control Boundary

Separate compile-time roots, human keys, scoped program signers, and limits the current code does not enforce.

This audit maps the authority checks present in the ten native NiceChunk program crates, including the unified namespace router. A compile-time key or one-time account is not, by itself, proof that an upgradeable deployment is immutable. None of the ten programs defines a custom msg!, sol_log, emit!, or event structure; audit evidence comes from account state, transaction history, CPIs, and transfers rather than an event stream.

Account Lifecycle Map

Follow PDA state from rent funding to migration, growth, closure, or durable settlement.

These maps explain how current contracts handle pre-funded PDAs, rent top-ups, realloc growth, legacy migration, and refund paths without turning transient accounts into invisible state.

Payload Truth Boundary

Separate user-supplied bytes from facts recomputed from PDAs, hashes, recipes, and rule evidence.

These maps show which payload fields are accepted as selectors or intent, and which item, building, recipe, identity, endpoint, and governance facts are re-derived from contract-owned evidence before state changes.

Value Settlement Map

Trace real token and lamport movement separately from item custody, rent, and governance evidence.

These maps show where SOL or NCK actually moves, where rent is only funding PDA storage, and where gameplay evidence changes state without becoming a payment rail.

Verifier Matrix

What an external reviewer should verify for each contract surface.

This matrix ties each program to the authority gate, PDA evidence, live proof, and current boundary that can be checked without trusting a private server.

Current NiceChunk programs and runtime status.

The table lists repository contracts, their program IDs, and whether the current game client references them. Client configuration does not by itself prove on-chain deployment or callability.

Live Flow

How the current gameplay path touches the chain.

Transparency Ledger

Players can audit the world from contract code to public PDA state.

NiceChunk treats public state as part of the game interface. Players should be able to inspect who exists, which backpacks and listings exist, what recipes are active, which regions serve realtime play, and which rules or accounts are still only planned.

Program Details

Contract code, instructions, PDA seeds, and stored data.

On-chain PDA Browser

Read the public devnet state directly from RPC.

Scan NiceChunk program accounts, decode known PDA layouts, and inspect players, build sites, buildings, backpacks, smelting tables, market listings, Guardian regions, and chunk deltas without trusting a private database.

PDA group Search

Developer Notes

Frontend and script integration references.

Program IDs

PDA seed examples

Current boundary

This page documents the current devnet-facing contract surface and the game runtime configuration loaded from mainnet.json. It does not claim final mainnet governance, live civilization execution, land ownership, complete realtime decentralization, or complete gameplay decentralization.