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
Proof of AccessNetwork Fee RoutingRelease VerificationMPC Treasury SecurityPSBT SecurityNode AuthenticationRate LimitingBundle Integrity VerificationTransaction Session Reconciliation
Docs/Security & Verification/Release Verification
Security & Verification

Release Verification

Client-side release verification. How users verify they are running authentic marketplace code without trusting any server.

#Release Verification

Release verification ensures users are running authentic, untampered marketplace code. All verification happens client-side using browser crypto APIs. No trusted server is needed.

#Manifest and Signature

Every release ships with two artifacts:

  • Manifest: a JSON document listing every served asset and its SHA-256 hash.
  • Signature: an Ed25519 signature over the canonical (deterministically serialized) manifest.

The release public key is published in the repository and well-known endpoints. Nodes pin this key and reject manifests signed by unknown keys.

#Client-Side Verification Flow

The browser performs these checks without any server trust:

typescript
async function verifyReleaseManifestClient(
  manifest: ReleaseManifest,
  signature: Uint8Array,
  publicKey: CryptoKey
) {
  // 1. Parse and validate manifest schema
  const parsed = ReleaseManifestSchema.parse(manifest);

  // 2. Canonical serialization (deterministic key ordering)
  const canonicalManifest = canonicalJSON(parsed);

  // 3. Verify Ed25519 signature against release public key
  const isValid = await crypto.subtle.verify(
    "Ed25519", publicKey, signature,
    new TextEncoder().encode(canonicalManifest)
  );
  if (!isValid) throw new Error("Invalid release signature");

  // 4. Hash the manifest payload for cross-node comparison
  const manifestHash = await crypto.subtle.digest(
    "SHA-256", new TextEncoder().encode(canonicalManifest)
  );

  // 5. Fetch each asset and verify its hash individually
  for (const asset of parsed.assets) {
    const response = await fetch(asset.path);
    const assetBytes = await response.arrayBuffer();
    const hash = await crypto.subtle.digest("SHA-256", assetBytes);
    if (toHex(hash) !== asset.expectedHash) {
      throw new Error("Asset tampered: " + asset.path);
    }
  }
}

#Network Consensus on Releases

Nodes track release manifests via RELEASE_MANIFEST_SEEN protocol events:

  • When a node detects a new release, it broadcasts a RELEASE_MANIFEST_SEEN event containing the manifest hash and its own signature.
  • All nodes record which release hash each peer is serving.
  • Strict mode: consensus requires all nodes to serve the same release hash. Nodes serving a different hash are flagged.
  • The marketplace UI includes a ReleaseGuard component that warns users immediately if a mismatch is detected between the serving node and network consensus.

#UI Integrity

Session attestation (see Node Authentication) binds the served content hash to the serving node identity. If a node serves tampered UI assets, the attestation will not match what other nodes expect, and clients can detect the discrepancy.

#Self-Verification

Because the marketplace is fully open source, any participant can:

  • Clone the repository and build from source.
  • Compute SHA-256 hashes of all build artifacts.
  • Compare those hashes against the signed release manifest.
  • Run their own node to serve verified code.
  • Inspect every line of the protocol validation engine.

#Security Guarantees

  • No trusted server. All verification uses browser-native crypto APIs (Web Crypto).
  • Canonical serialization. Deterministic JSON key ordering prevents order-dependent tampering.
  • Full asset verification. Every served file (JS bundles, CSS, images) is individually hash-checked.
  • Public key pinning. The release signing key is published and embedded in well-known endpoints.
  • Consensus enforcement. Nodes serving incorrect hashes are flagged via gossip protocol events.
  • Tamper detection. Any modification to any single byte of any served asset is caught.
PreviousNetwork Fee RoutingNext MPC Treasury Security

On this page

  • Release Verification
  • Manifest and Signature
  • Client-Side Verification Flow
  • Network Consensus on Releases
  • UI Integrity
  • Self-Verification
  • Security Guarantees