Technical Architecture

System Overview

Quantum Core consists of three main components working together to capture, process, and permanently record quantum randomness on the blockchain.

┌─────────────────────────────────────────────────────────────────┐
│                        QUANTUM CORE                             │
├─────────────────┬─────────────────────┬─────────────────────────┤
│   Publisher     │   Smart Contract    │   Frontend Dashboard    │
│   Service       │   (On-Chain)        │   (Web Application)     │
└─────────────────┴─────────────────────┴─────────────────────────┘

Component Details

1. Publisher Service

The publisher is a backend service responsible for:

• Fetching quantum random data from the ANU QRNG API

• Processing the data (hashing, metadata creation)

• Submitting transactions to Solana and XRPL blockchains in parallel

• Scheduling regular publication intervals

Technology Stack:

• Runtime: Node.js / TypeScript

• Blockchain SDKs: @solana/web3.js, xrpl

• Hosting: Cloud infrastructure with high availability

Key Functions:

// Fetch quantum random data
fetchQuantumData(): Promise<string>

// Process and hash the data
processQuantumBytes(data: string): { hash: string, timestamp: number }

// Submit to blockchain
publishPulse(hash: string, source: string): Promise<{
  solana: TransactionSignature,
  xrpl: string
}>

2. Solana Smart Contract (Program)

The on-chain program manages the storage and retrieval of quantum pulse data.

Program ID: 6JmMTwYMe7g8ZThH7dxZPCAey9Bda42Wi2HgUz84R3Tn

Network: Solana Devnet

Account Structure:

// State Account - Tracks global statistics
pub struct State {
    pub pulse_count: u64,      // Total pulses published
    pub authority: Pubkey,      // Program authority
    pub last_timestamp: i64,    // Last publication time
}

// Pulse Account - Individual quantum pulse data
pub struct Pulse {
    pub id: u64,               // Sequential identifier
    pub hash: [u8; 32],        // SHA-256 hash of quantum data
    pub src: String,           // Source identifier
    pub timestamp: i64,        // Unix timestamp
}

Instructions:

Instruction	Description
initialize	Set up program state
publish_pulse	Record a new quantum pulse

Program Derived Addresses (PDAs):

• State PDA: Derived from ["state"] seed

• Pulse PDAs: Derived from ["pulse", pulse_id] seeds

3. XRPL Memo Transactions

Quantum pulse data is also recorded on the XRP Ledger using memo transactions.

• Destination Address: rs1XDtrWxmyfq2LpMUB3huchx7h61bBsLj

• Network: XRPL Testnet

{
  TransactionType: "Payment",
  Amount: "1",                    // 1 drop (minimal amount)
  Destination: "rs1XDtrWxmyfq2LpMUB3huchx7h61bBsLj",
  DestinationTag: timestamp,      // For uniqueness
  Memos: [{
    Memo: {
      MemoType: "quantum_pulse",  // Hex encoded
      MemoData: {                 // Hex encoded JSON
        type: "quantum_pulse",
        id: number,
        hash: string,             // SHA-256 hash
        src: "ANU-QRNG",
        timestamp: number
      }
    }
  }]
}

4. Frontend Dashboard

The web application provides a user interface for viewing and verifying quantum pulses.

Key Features:

• Real-time pulse display with multi-chain support

• Chain filter (Solana, XRPL, or both)

• Historical pulse browsing

• On-chain verification links for both explorers

• Cross-chain pulse merging (same hash shown as single card)

• Educational content

• Responsive design (mobile-friendly)

Data Structures

Pulse View (Frontend)

interface PulseView {
  id: number;           // Pulse identifier
  hash: string;         // SHA-256 hash (hex string)
  src: string;          // Source ("ANU-QRNG")
  timestamp: number;    // Unix timestamp
  address: string;      // On-chain account address
  chain: string;        // Blockchain identifier
  chains?: ChainInfo[]; // All chains where this pulse exists
}

On-Chain Data Layout

┌────────────────────────────────────────────┐
│              Pulse Account                 │
├────────────────────────────────────────────┤
│  Discriminator    │  8 bytes               │
│  ID               │  8 bytes (u64)         │
│  Hash             │  32 bytes ([u8; 32])   │
│  Source Length    │  4 bytes (u32)         │
│  Source String    │  Variable              │
│  Timestamp        │  8 bytes (i64)         │
└────────────────────────────────────────────┘

┌────────────────────────────────────────────┐
│           Transaction Memo                 │
├────────────────────────────────────────────┤
│  MemoType         │  "quantum_pulse"       │
│  MemoData (JSON)  │                        │
│    - type         │  "quantum_pulse"       │
│    - id           │  number                │
│    - hash         │  64-char hex string    │
│    - src          │  "ANU-QRNG"            │
│    - timestamp    │  Unix timestamp        │
└────────────────────────────────────────────┘

Network Configuration

Blockchain RPC Endpoints

Environment	Endpoint
SOL Devnet	https://api.devnet.solana.com
XRPL Testnet	wss://s.altnet.rippletest.net:51233

External APIs

Service	Endpoint
ANU QRNG	https://api.quantumnumbers.anu.edu.au

Monitoring and Observability

The system includes monitoring for:

• Pulse Publication: Track successful vs failed publications

• Transaction Status: Monitor confirmation times

• API Health: ANU QRNG availability checks

• Wallet Balances: Ensure sufficient SOL and XRP for transactions

Scalability Considerations

The architecture is designed to scale:

• Horizontal Scaling: Multiple publisher instances can run concurrently

• Efficient Storage: PDAs enable O(1) pulse lookups

• Caching: Frontend caches recent pulses for performance

• Rate Limiting: Prevents API and RPC overload