agorix
AirdropMarketsCollectionsLeaderboardActivity
Agorix · Decentralized Marketplace
Independent · Resilient · Community-Run

A cross-chain marketplace, run by the community.

Discover, list, and trade across Bitcoin, Ethereum, and Solana on an open, community-run network.

Marketplace
CollectionsMarketsLeaderboardActivity
Network
GovernanceExplorerAirdropDocs
Account
ProfileSettings
Legal
Terms of ServicePrivacy PolicyYour Privacy Choices
agorix.io — Lasting Access
CID: 0xA60R1X · v0.1
AirdropMarketsCollections
D
Protocol Docs
OverviewHow It WorksRunning a NodeArchitecture
Docs/Getting Started/Running a Node
Getting Started

Running a Node

Complete guide for node operators. System requirements, chain infrastructure, staking economics, environment configuration, capabilities, full-node mode, Docker deployment, and dev commands.

#Running a Node

Every node in the network is a full marketplace operator. You earn fees by processing transactions, validating protocol truth, and participating in governance.

#System Requirements

ResourceMinimumRecommended
CPU4 cores8 cores
RAM8 GB16 GB
Storage100 GB SSD500 GB NVMe
Network100 Mbps1 Gbps
Node.js20+Latest LTS
Rust toolchainstableLatest stable
PostgreSQL16+16+
Redis7+7+

#Chain Infrastructure Requirements

You need RPC access to the chains you want to support. The Proof-of-Access challenge system continuously verifies that your access is real and responsive:

Bitcoin:

  • bitcoind full node (pruned is acceptable for basic operations, full is recommended)
  • ord indexer (required for ordinal support -- this is mandatory for BTC capability)
  • Both are needed because PoA challenges test both BTC chain state and ordinal indexer state separately (5 challenges total)

Ethereum / EVM:

  • RPC endpoint for each supported chain (Ethereum, Base, Arbitrum, Optimism)
  • Options: Alchemy, Infura, QuickNode, or self-hosted Geth/Erigon/Reth
  • Archive node access recommended for historical PoA challenges

Solana:

  • RPC endpoint with full account and transaction history
  • Options: Helius, QuickNode, Triton, or self-hosted validator

#Environment Configuration

Key environment variables for node operation:

text
# Node identity
NODE_ID=1                              # Unique integer node identifier
AGENT_SECRET_KEY_B64=<base64>          # Ed25519 secret key for signing all events

# Database and cache
DATABASE_URL=postgres://user:pass@localhost:5432/agorix
REDIS_URL=redis://localhost:6379

# Rust node-core
RUST_NODE_CORE_URL=http://localhost:9100  # The Rust microservice endpoint

# Network
GATEWAY_DISCOVERY_URL=https://gateway.example.com

# Bitcoin
BTC_NETWORK=mainnet                    # or testnet, signet, regtest
BTC_RPC_URL=http://localhost:8332
ORD_RPC_URL=http://localhost:8080

# Ethereum / EVM
EVM_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/<key>
BASE_RPC_URL=https://base-mainnet.g.alchemy.com/v2/<key>
ARB_RPC_URL=https://arb-mainnet.g.alchemy.com/v2/<key>
OP_RPC_URL=https://opt-mainnet.g.alchemy.com/v2/<key>

# Solana
SOL_RPC_URL=https://mainnet.helius-rpc.com/?api-key=<key>

# Full-node mode (optional)
FULL_NODE_CHAT=0                       # Set to 1 to store all chat threads
FULL_NODE_MEDIA=0                      # Set to 1 to cache all media entries

#What Runs on Each Node

When you start a node, the following components run:

  • Next.js application -- UI, API routes, tRPC server, and WebSocket connections for real-time quote serving and updates
  • Rust node-core microservice (port 9100) -- 60+ endpoints handling PSBT validation, Ed25519 signing, AES-GCM encryption/decryption, Shamir secret sharing, scanner loops for mempool and block watching
  • PostgreSQL 16 database -- completely isolated per node. No shared database exists anywhere in the system. Protocol data is replicated via gossip, not database replication.
  • Redis 7 instance -- caching, rate limiting, real-time state, and pubsub for internal coordination
  • WebSocket server -- gossip mesh connections to peers, plus client-facing sockets for live price quotes

#Staking Economics

To join the network, you must bond a stake. The minimum stake follows a dynamic curve that increases as the network grows:

text
minimumStake = minStakeUsd + (increment * nodeCount^0.75)

This sub-linear curve means the cost of joining grows more slowly than the network itself. Early operators get in cheaply; later operators pay more but join a more valuable network.

ParameterValue
Admission fee5% of stake (non-refundable, burned)
Cooldown period24 to 168 hours (governance-configurable)
SlashingBond at risk for provable misbehavior
DelegationDelegates forfeit fees, accrue escalating cooldowns

Delegates who exercise votes on behalf of delegators forfeit their own fee earnings and accumulate longer unstake cooldowns. This ensures delegation is a public service, not a profit center.

#Node Capabilities

Each node advertises its capabilities via /.well-known/agent. The protocol uses these to determine which nodes are eligible for specific roles:

CapabilityDescription
btc_mempool_watchMonitors Bitcoin mempool for relevant transactions
btc_block_watchWatches new Bitcoin blocks for confirmations
ord_index_readReads ordinal inscription and transfer data from ord
btc_psbt_share_storeStores encrypted Shamir PSBT shards
btc_psbt_share_revealReveals PSBT shards during settlement
protocol_validateRuns validateSaleTx() and other protocol checks
protocol_attestSigns witness attestations for transactions
gossip_relayRelays protocol events to mesh peers
ui_quote_serviceServes real-time price quotes to frontend clients
public_serverNo longer used. Servers are picked for each visitor from the measured route map; there is no public list to be on

A node that lacks ord_index_read will never be selected as a witness for Bitcoin ordinal transactions. Capabilities are verified through PoA challenges -- you cannot fake them.

#Full-Node Mode

By default, nodes only store data they are responsible for via the shard ring. You can opt into storing everything:

  • FULL_NODE_CHAT=1 -- Store all chat threads instead of only your assigned shards
  • FULL_NODE_MEDIA=1 -- Cache all media entries instead of only your assigned shards

Full-node mode does NOT affect PSBT shard distribution. PSBT shards are always distributed via the Shamir 3-of-4 scheme to specific shard-holder nodes regardless of full-node settings.

Full-node mode increases storage requirements significantly but improves data availability and query performance for your node's users.

#Docker Deployment

The repository includes Docker Compose profiles for different deployment scenarios:

ProfileWhat it starts
infraPostgreSQL + Redis only (for local development against existing code)
fullPostgreSQL + Redis + Node app + Rust node-core (complete node)
gatewayFront-door-gateway (stateless edge proxy, depends on cache only)

#Development Commands

For local development and testing:

text
# Start the full development environment
pnpm dev

# Start a local multi-node cluster (simulates network locally)
pnpm dev:cluster

# Chain-specific development modes
pnpm dev:btc     # Bitcoin-focused development with regtest
pnpm dev:evm     # EVM-focused development with local Hardhat/Anvil
pnpm dev:sol     # Solana-focused development with local validator

#Joining the Network

  • Deploy the node software (all code is open source)
  • Configure your chain RPC endpoints and environment variables
  • Start the node and Rust node-core service
  • Submit a staking transaction (minimum bond + 5% admission fee)
  • Register via the NODE_ANNOUNCE protocol event (Ed25519 signed)
  • Pass Proof-of-Access challenges for each claimed capability
  • Begin receiving transaction assignments and gossip events
  • Participate in governance (1-Node-1-Vote on all proposals)

#Open Source

The node software is fully open source. You can inspect every line of code, verify every protocol rule, and propose improvements through governance. There is nothing proprietary. The entire marketplace runs on transparent, auditable code. All foundation actions are signed protocol events gossiped to every node and visible in the explorer.

PreviousHow It WorksNext Architecture

On this page

  • Running a Node
  • System Requirements
  • Chain Infrastructure Requirements
  • Environment Configuration
  • What Runs on Each Node
  • Staking Economics
  • Node Capabilities
  • Full-Node Mode
  • Docker Deployment
  • Development Commands
  • Joining the Network
  • Open Source