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
Public APISmart ContractsSecurity ModelOpen SourceRust Node CoreGetting Started (Developer)Benchmarks
Docs/Developer/Open Source
Developer

Open Source

Complete open source codebase. Repository structure, package architecture, and how anyone can verify, contribute, and operate a node.

#Open Source

Every component is open source. No proprietary components, no hidden services, no closed-source dependencies in the critical path. You can read every line of code that processes your trades.

#What's Open Source

ComponentDescription
Protocol EngineDeterministic validation rules (TypeScript + Rust)
Node SoftwareComplete node runtime with all services
GatewayFront-door routing layer
Smart ContractsEVM and Solana marketplace/staking contracts
ExplorerProtocol transparency UI
Benchmark DashboardPerformance testing and visualization
DocumentationThis documentation site
Test InfrastructureE2E cluster testing, security tests, benchmarks

#Repository Structure

text
decenterlizemarket/
├── packages/
│   ├── protocol/          # Consensus rules (pure Zod schemas, zero deps, deterministic)
│   ├── db/                # Database schemas (Drizzle ORM, PostgreSQL)
│   ├── agent/             # Node runtime (mesh networking, gossip, peer management)
│   ├── server/            # Business logic (tRPC routers, API handlers)
│   ├── cache/             # Redis client, rate limiting, caching layer
│   └── external-gateway/  # Stateless routing and load balancing
├── services/
│   ├── node-core/         # Rust microservice (60+ endpoints)
│   └── benchmark-dashboard/  # Dev benchmark platform (P5.js, live streaming)
├── contracts/             # Solidity smart contracts (Hardhat/Foundry)
├── programs/              # Solana Anchor programs
├── src/                   # Next.js application (marketplace UI)
├── __tests__/             # Integration and E2E test suite
│   └── app/api/           # API route tests
├── scripts/               # Deployment, migration, and testing scripts
└── docs/                  # Protocol documentation

#Package Architecture

services/protocol — The protocol package is the foundation. Zero external dependencies. Pure Zod schemas and deterministic validation functions. Every node must compute identical results from identical inputs. If it's in the protocol package, it must be deterministic.

services/db — Drizzle ORM schemas for PostgreSQL. Each node has its own isolated database (no shared DB). Protocol data is fully replicated via gossip; chat data is sharded across nodes.

services/agent — The node runtime. Mesh networking, gossip protocol, peer discovery, heartbeat management, and the main node lifecycle. This is what runs when you start a node.

services/server — Business logic layer built on tRPC. API route handlers, chain-specific settlement logic, PSBT management, PoA challenge generation, and the documentation engine.

services/cache — Redis client with rate limiting middleware and caching utilities. Handles the escalating rate limit tiers (5min → 15min → 60min → 24h + gossip ban).

external gateway project — Stateless request routing. Directs incoming requests to the appropriate handler without maintaining session state.

#Why Open Source

For Users: Verify the rules governing your trades. Confirm there are no hidden fees or backdoors. Build confidence that the protocol is fair.

For Operators: Inspect every line of code your node runs. Audit the protocol validation engine. Propose improvements through governance.

For Developers: Build on top of the public API. Contribute protocol improvements. Fork and experiment. Run the benchmark dashboard to verify performance claims.

#Self-Verification

  • Clone the repository.
  • Read the protocol engine at services/protocol/src/.
  • Build from source and compare against release manifests.
  • Run the full test suite (pnpm test).
  • Run your own node to serve independently verified code.
  • Verify on-chain that smart contract source matches deployed bytecode.
  • Run benchmarks to validate performance claims (pnpm bench:dashboard).

#Verify, Don't Trust

The entire system is designed around one principle: every claim the protocol makes is independently verifiable. Open source isn't a marketing feature here. It's a security requirement. A decentralized marketplace where you can't read the code isn't decentralized at all.

PreviousSecurity ModelNext Rust Node Core

On this page

  • Open Source
  • What's Open Source
  • Repository Structure
  • Package Architecture
  • Why Open Source
  • Self-Verification
  • Verify, Don't Trust