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/Overview
Getting Started

Overview

What Agorix is and why it exists. A chain-agnostic, agent-run decentralized marketplace where distributed nodes enforce transparent, deterministic rules across Bitcoin, Ethereum, Solana, and beyond.

#What is Agorix?

Agorix is a decentralized, agent-run, multi-chain marketplace protocol -- an eBay replacement for digital assets. Instead of one company running your trades, a network of independently operated nodes enforces the rules. The rules are code. Every node can verify them. Nobody can change them unilaterally.

The protocol works natively across Bitcoin, Ethereum (plus L2s like Base, Arbitrum, and Optimism), Solana, and additional chains on day one. Every transaction is validated by a quorum of witnesses selected through a deterministic process that nobody can predict or game ahead of time.

#The Problem

Right now, digital asset marketplaces are centralized chokepoints.

  • Platform risk. OpenSea, Magic Eden, Blur -- they all make unilateral decisions about listings, fees, and policies. Your assets, their rules.
  • Opaque economics. Hidden incentives, wash trading rewards, fee structures nobody can audit.
  • Chain fragmentation. Every blockchain needs its own platform. Liquidity gets split across all of them.
  • Centralized settlement. One server processes your transactions. One server goes down, everything stops. One company gets compromised, everyone loses.

#The Solution

We replace centralized trust with cryptographic verification.

  • Chain-Agnostic Protocol Truth. The same transparent, cryptographically verifiable rules run identically on every supported chain. The protocol package has zero framework dependencies -- it is pure Zod schemas and deterministic logic.
  • Distributed Threshold Attestation. Independent bonded nodes must reach supermajority agreement (2/3 threshold) before any settlement happens. Witnesses are selected deterministically using unpredictable seeds derived from block hashes.
  • Native Multi-Chain Settlement. Bitcoin PSBTs with Shamir 3-of-4 share distribution, EVM EIP-712 signed orders via AgorixV1.sol, Solana SPL transfers via the agorix_marketplace program. No bridges, no wrapping, no synthetic assets. Your tokens stay native.
  • 1-Node-1-Vote Governance. Stake gets you in the door, but every node gets exactly one vote. No plutocratic capture. Token weighting is explicitly rejected.

#Supported Chains and Standards

ChainStandardsSettlement Mechanism
BitcoinOrdinals, PSBTsPSBT reconstruction from Shamir shards
EthereumERC-721, ERC-1155, ERC-20AgorixV1.sol smart contract
BaseERC-721, ERC-1155, ERC-20EVM smart contract (L2)
ArbitrumERC-721, ERC-1155, ERC-20EVM smart contract (L2)
OptimismERC-721, ERC-1155, ERC-20EVM smart contract (L2)
SolanaSPL tokensagorix_marketplace program

#Key Metrics

MetricValue
Supported chains10+ (day one)
Consensus thresholdSupermajority (2/3 witnesses)
Protocol event types46
Centralized chokepoints0
Marketplace fee2% (50/50 foundation/nodes)
Event signingEd25519

#Technology Stack

The system is built on a modern, high-performance stack:

  • Frontend: Next.js 15 with React 19
  • Backend: TypeScript (Next.js API routes + tRPC) and Rust (Axum-based node-core)
  • ORM: Drizzle ORM with strict schema typing
  • Database: PostgreSQL 16 (isolated per node)
  • Cache: Redis 7 (rate limiting, real-time state, caching)
  • Protocol: Pure TypeScript with Zod validation, zero framework dependencies
  • Cryptography: Ed25519 signing for all events, AES-GCM for PSBT encryption, Shamir secret sharing

#Monorepo Structure

The codebase is organized into 8 packages and 2 services:

Packages:

PackagePurpose
protocolZero-dependency consensus schemas, event types, and deterministic logic
dbDrizzle ORM schemas, migrations, and query helpers
agentGossip mesh networking, peer discovery, and event propagation
serverBusiness logic, tRPC routers, and API handlers
cacheRedis client, rate limiting, and caching strategies
configEnvironment validation, feature flags, and node configuration
cliCommand-line tooling for node operators
front-door-gatewayStateless edge proxy depending only on cache

Services:

ServicePurpose
node-coreRust (Axum) microservice with 60+ endpoints for PSBT validation, Ed25519 signing, AES-GCM encryption, and scanner loops
benchmark-dashboardDevelopment performance dashboard with live streaming

#Architecture at a Glance

The packages follow strict dependency rules. An arrow means "depends on":

text
protocol  (zero framework deps, pure Zod schemas + deterministic logic)
    |
    v
   db      (protocol + Drizzle ORM + PostgreSQL 16)
   / \
  v   v
agent  server  (protocol + db + cache + config)
  |      |
  v      v
cache   (ioredis, standalone)
  |
  v
front-door-gateway  (cache only, stateless edge proxy)

Every node runs its own isolated PostgreSQL database. There is no shared database anywhere in the system. Protocol data (events, attestations, governance votes) gets fully replicated through the gossip protocol so every node has the same view of protocol truth. Chat data gets sharded across nodes via rendezvous hashing with configurable replica counts.

#46 Protocol Event Types

All protocol events are Ed25519-signed and gossiped to the entire network. They cover:

  • Listings: creation, updates, cancellation, expiration
  • Orders: intent, confirmation, cancellation
  • Transactions: observation, attestation, finalization, disputes
  • Governance: proposals, votes, delegation, parameter changes
  • Node lifecycle: announcements, staking, unstaking, capability updates
  • Rewards: claim creation, signing, invalidation
  • Moderation: reports, reviews, strikes
  • Foundation: treasury actions, emergency operations (all transparent, all signed)

#The Core Idea

What if marketplace rules were code that every node can verify, not policies that one company can change? And what if that worked on every chain?

We don't replace the marketplace. We replace the trust model.

Next How It Works

On this page

  • What is Agorix?
  • The Problem
  • The Solution
  • Supported Chains and Standards
  • Key Metrics
  • Technology Stack
  • Monorepo Structure
  • Architecture at a Glance
  • 46 Protocol Event Types
  • The Core Idea