Public Verifier

Every event in the PAX operational ledger is hash-chained, batched into a Merkle tree, and anchored to external tamper-evident storage. This page exposes the verifier surface so any auditor, investor, or third-party developer can independently reconstruct the chain and confirm inclusion for any fill — without contacting PAX support and without trusting the PAX API.

Live status

Refreshes on page load from GET /v1/audit/status. If you see counts, the chain is running.

The chain model

Three layers of tamper evidence, each independently verifiable by third parties:

Verifier endpoints (no auth required)

All six endpoints are public, read-only, and rate-limited per source IP. Response envelope is the canonical {data, meta} shape with trace_id for support debugging.

Interactive verify demo

Enter an event seq below. The page will fetch the event + its Merkle inclusion proof + the batch's merkle_root, then verify the proof entirely in your browser (WebCrypto SHA-256, OpenZeppelin sorted-pair). The result is computed client-side — no need to trust the PAX response.

Reproduce it in your own code

The verify algorithm is 5 lines. Everything below runs locally against the public endpoints — you never need to trust PAX to compute the answer.

TypeScript / Node

// npm i @predictasiax/api
import { PaxClient, AuditResource } from '@predictasiax/api';

const pax = new PaxClient({ apiKey: 'anonymous' });   // audit endpoints are no-auth

const seq = 110841;
const proof = await pax.audit.getProof(seq);

// Node crypto (sync)
const ok = AuditResource.verifyProof(
  proof.event_hash,
  proof.batch.merkle_root,
  proof.merkle_proof,
);

// Browser / edge (WebCrypto async)
const okAsync = await AuditResource.verifyProofAsync(
  proof.event_hash,
  proof.batch.merkle_root,
  proof.merkle_proof,
);

console.log('Verified locally:', ok);   // true

Python

# pip install pax-api
from pax_api import PaxClient

pax = PaxClient(api_key="anonymous")   # audit endpoints are no-auth

seq = 110841
proof = pax.audit_proof(seq)["data"]

ok = PaxClient.verify_merkle_proof(
    leaf=proof["event_hash"],
    root=proof["batch"]["merkle_root"],
    proof=proof["merkle_proof"],
)
print("Verified locally:", ok)   # True

Bare curl + shasum (no SDK)

# 1. Fetch the event + its Merkle proof
curl -s https://api.predictasiax.com/v1/audit/proof/110841 | jq

# 2. Verify in shell (OpenZeppelin sorted-pair sha256)
verify() {
  local h=$1 root=$2 shift 2
  local proof=("$@")
  for s in "${proof[@]}"; do
    if [[ "$h" < "$s" ]]; then pair="${h}${s}"; else pair="${s}${h}"; fi
    h=$(printf '%s' "$pair" | shasum -a 256 | cut -c1-64)
  done
  [[ "$h" == "$root" ]] && echo OK || echo MISMATCH
}

Solidity (on-chain)

// The Merkle algorithm is bit-identical to OpenZeppelin's MerkleProof —
// the proofs returned by /v1/audit/proof/{seq} work on-chain without change.
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

function verifyPaxEvent(
  bytes32 leaf,       // event_hash from /v1/audit/proof/{seq}
  bytes32 root,       // merkle_root from same response
  bytes32[] calldata proof   // merkle_proof array
) public pure returns (bool) {
  return MerkleProof.verify(proof, root, leaf);
}

What this proves for you

• Order → fill provenance. Every trade emits an event into event_log. If your app routed the trade, the event's payload carries your execution_builder_id — publicly verifiable via /v1/audit/events/{seq}.
• Attribution integrity. The 7-actor PAF split (computeFeeSplit in apps/api/src/index.ts) writes idempotent financial_event rows keyed by fee_split:<trade_id>:<event_type>. The same trade cannot be double-attributed even under retry storms.
• Fee estimate = settlement. The POST /v1/fees/estimate endpoint and the fill-time settlement path both call the same computeFeeSplit function with the same PAF_BASE_BPS / PAF_FLOOR_BPS / PAF_CEILING_BPS constants. The estimate returned before your trade uses identical math to the settlement — divergence would require the API to run two different builds simultaneously, which the deploy pipeline forbids.
• Tamper-evidence outlives the API. R2-anchored batches persist as immutable signed blobs. Even if api.predictasiax.com were compromised, historical anchors let auditors detect after-the-fact rewrites of past events.