Atho logo Atho
All Pages
Home Docs Falcon-512 Join Rewards Wallet Wallet Hierarchy Platinum Shield BPoW Inflation / Deflation Changelog Roadmap Contact
Platinum Shield Privacy Layer Layer-1 Public + Private Coexistence

Atho — Private. Secure. The Platinum Standard of the Quantum Age.

Platinum Shield extends Atho Layer 1 with deterministic private-note semantics while preserving standard public UTXO operation. Public and private routes can interoperate without weakening consensus policy: every spend path remains version-gated, audit-addressable, and fail-closed on verification errors.

Public -> Private Private -> Private Private -> Public PrivateTx v3 Bundle + X-Address Binding Nullifier Replay Protection
Explore Flow Engine Wallet Private Send Privacy Documentation Download PrivateTx v3 Testnet Runbook

What Platinum Shield Enforces

  • Recipient binding Bundle hash and x-address must match on receive/validation or the transaction is rejected.
  • Nullifier uniqueness Private inputs consume nullifiers once; duplicate/nullifier-index conflicts are blocked at mempool and block validation.
  • Network-domain separation Signatures, addresses, and witness material are network-bound to prevent cross-network replay.
  • Consensus compatibility Public UTXO validation rules stay intact while private note commitments/nullifiers layer on top in deterministic order.
End-to-End Workflow Engine

How every send path moves through Layer 1.

The same transaction lifecycle applies to all paths: wallet assembly, mempool admission, consensus validation, block inclusion, and state reconciliation. The difference is which value domains are consumed and produced at each step.

Public -> Private

Spend public UTXOs, produce private note commitments.

Private -> Private

Consume private notes by nullifier, create new private notes.

Private -> Public

Consume private notes, release value back to public UTXO outputs.

Flow Sequence (All Paths)

  1. Wallet node resolves sender role/address, checks unlock policy, and assembles deterministic intent metadata.
  2. Destination payload is validated: recipient bundle parsing, x-address binding, amount normalization, and version gates.
  3. Mempool performs structural and consensus prechecks, including private note/nullifier conflict checks when present.
  4. Block assembly revalidates all invariants, then commits state transitions to public UTXO and private note domains.
  5. Post-apply reconciliation marks pending private notes as spent/confirmed and logs each transition for audit trails.

State Objects Across the Path

  • Public UTXO set Confirmed outputs, pending debits/credits, and fee accounting remain canonical for transparent value paths.
  • Private note set Commitments, note payload metadata, note state journal (unspent/pending/spent), and deterministic ownership linkage.
  • Nullifier index Consensus-visible anti-double-spend map for private inputs with fail-closed block admission rules.
Platinum Shield Annotations

Annotated private transaction pipeline from wallet intent to block acceptance.

These annotations map the product flow to concrete consensus objects so operators can quickly understand how private sends move through mempool, block assembly, STARK proving, and state apply.

Stage 1: Wallet Assembly

  • Intent buildWallet resolves route type (public->private, private->private, private->public) and assembles deterministic tx intent metadata.
  • Bundle bindingRecipient bundle hash and x-address are linked before relay; mismatches are expected to fail validation.
  • Mempool amount modePrivate outputs carry amount_plain during mempool policy checks for deterministic arithmetic validation.

Stage 2: Mempool Gate

  • Structure checksTransaction shape, version gates, and private field presence are validated before propagation.
  • Nullifier conflict checksConfirmed-nullifier and pending-nullifier indexes reject competing private spends.
  • Replay guardsNetwork-domain separated hashes prevent cross-network replay acceptance.

Stage 3: Miner Block Assembly

  • Commitment conversionMiner converts private outputs from mempool representation into block commitment form (amount_commit).
  • STARK prove stepPrivate amount consistency proof is generated through the STARK bridge/backend runtime path.
  • Fail-closed policyIf proving runtime fails, private-activity block production fails closed by design.

Stage 4: Consensus Verify + Apply

  • Proof verificationNodes verify block-level STARK proofs during block acceptance.
  • Dual-domain applyPublic UTXO updates and private note/nullifier transitions are committed in one deterministic connect path.
  • Reorg safetyPrivate-state transitions are applied/reverted with block connect/disconnect so reorg behavior remains deterministic.

Field Glossary (Fast Reference)

  • commitPrivate output commitment stored on-chain for note-state validity.
  • nullifierOne-time private input marker used to prevent double-spend replay.
  • anchorMerkle root reference used to bind private spends to an allowed tree state.
  • enc_payloadRecipient-encrypted note material (Kyber path) used for receive/recovery.
  • Hidden-supply accumulatorDeterministic private-activity accumulator included in proof statement checks.

Public and Private on Layer 1

Platinum Shield does not replace public UTXOs. It introduces a private note domain that coexists with the public UTXO model under one consensus timeline. Public outputs remain openly auditable, while private outputs track commitments + nullifiers with deterministic validation hooks.

  • Public domain Transparent send/receive, standard fee policy, and normal UTXO verification rules.
  • Private domain Commitment-based note lifecycle with encrypted payload support and recipient binding enforcement.
  • Bridge operations Public -> private and private -> public transitions are first-class flows, not sidecar systems.

Replay and Integrity Controls

  • Network replay defense Message/signature material is domain-separated by network context, preventing cross-network acceptance.
  • Bundle/X-address quality control Receiver-side checks verify x-address hash consistency against bundle hash before accepting note payloads.
  • Deterministic key material generation Wallet-side note key derivation is deterministic per seed/account/counter path, enabling reproducibility and audits.
  • Fail-closed verification Invalid private witness/proof/binding data causes hard rejection at validation boundaries.
Node Responsibilities

Wallet, full, and miner nodes have distinct roles in private tx reliability.

Wallet Node

Primary private flow orchestrator.

  • Builds private sendsAssembles recipient bundle/x-address payloads, deterministic note seeds, and funding mode.
  • Manages note journalTracks unspent, pending_spend, spent transitions and reconciles against chain/store state.
  • Per-send auth policyEnforces wallet lockbox password requirements for sensitive private operations.
Wallet API

Full Node

Consensus validator and propagation gate.

  • Mempool validationRejects malformed private fields, duplicate nullifiers, and invalid spend semantics before relay.
  • Block-level enforcementRe-checks public and private invariants during block acceptance.
  • P2P propagation disciplineOnly valid private/public hybrid transactions are relayed to peers.
Consensus Gate

Miner Node

Policy-compliant block construction under BPoW.

  • Includes verified private txsSelects only transactions that pass full validation and policy thresholds.
  • Preserves deterministic accountingMaintains fee routing and emission constraints while carrying private/public flows.
  • Produces audit logsRecords private tx inclusion/failure traces for operator review and incident analysis.
Block Producer

Production posture comes from deterministic controls, not hidden assumptions.

Platinum Shield is designed so every private-path decision has explicit validation boundaries, deterministic state transitions, and traceable logs. This keeps privacy features compatible with strict Layer-1 operational discipline.

Version-gated tx semantics Nullifier anti-double-spend Bundle hash/x-address binding Network replay defenses Fail-closed verifier behavior

Next operator actions

  • Run private send testingUse testnet to run public->private, private->private, and private->public transaction loops.
  • Monitor logs by domainTrack mempool admits/rejects, block include outcomes, and note reconciliation events.
  • Review docs and runbooksKeep wallet/full/miner node procedures aligned with the latest privacy-layer policies.
Wallet Private Flow Privacy Docs Private Testnet Runbook