Architecture
The Triple-Threat Stack
Three non-negotiable architectural choices that make Shard-Lock physically unruggable and economically hyper-efficient.
Hardware-Anchored Trust
Every heartbeat is signed inside the Seeker's Secure Enclave (TEE). No TEE signature, no rewards. You cannot fake a node with a script — you need the physical device. Sybil attacks are architecturally impossible.
Jito BAM Verification
TEE attestations are verified off-chain by a specialized Jito BAM sidecar, batched into atomic bundles, and landed on-chain with zero Compute Unit overhead. High-frequency mobile telemetry, zero L1 bloat.
ZK-Compressed State
Using Light Protocol, we compress an entire node registry into a single ZK-root on-chain. On-chain rent costs drop by 90%, making million-node mobile infrastructure economically viable for the first time.
Operational Manual
From Download to Genesis
The Handshake
Connect your Phantom wallet to the dashboard and download the Android APK. This establishes your cryptographic Node Identity.
Node Funding
Request 0.025 SOL via our Devnet Faucet. This small reserve fuels all on-chain heartbeats and node registration fees.
TEE Activation
Launch the app. The Secure Enclave (TEE) performs a hardware handshake with the Solana Smart Contract, verifying your hardware integrity.
Yield Generation
Keep the app active. Your node securely locks data shards, submits periodic heartbeats, and accrues $SKR yield in real-time.
Verification Protocol
Mathematical Certainty
We don't trust the user. We trust the silicon. Shard-Lock uses a high-frequency attestation stack to ensure 100% state fidelity.
// Shard Verification Logic
pub fn verify_shard_proof(ctx: Context, root: [u8; 32]) {let node = &ctx.accounts.node_data;
require!(node.root == root, Error::InvalidProof);
emit!(HeartbeatVerified { node_pubkey: node.key });
}
Why Us
We Build
the Plumbing
Nobody wants to sit in JNI hell getting Android's Secure Enclave to sign
an Ed25519 payload without leaking memory. We do. The actual production
signing payload packed inside generateHeartbeat:
let mut message = Vec::with_capacity(44);
message.extend_from_slice(&root_bytes);
message.extend_from_slice(&(shard_count as u32).to_le_bytes());
message.extend_from_slice(&(timestamp as u64).to_le_bytes());
let signature = signing_key.sign(&message);
That's real production code — cross-compiled Rust running inside the Seeker's TEE boundary, bridged to Kotlin via JNI, submitting on-chain. That's what makes this different from a demo.
Roadmap
From Genesis
to Ambient Mesh
Phase 1: Genesis Milestone
- On-chain Anchor program deployed
- Android Rust-Core JNI bridge
- Cross-Network Faucet API
- Hardware Handshake verified
- Initial Aether Indexer live
Phase 2: Public Alpha
- Whitelist-gated node onboarding
- Direct APK sideloading distribution
- Live Yield Telemetry Visualization
- Devnet Incentivized Testing
- 10+ Genesis Nodes Active
Phase 3: Testnet Hardening
- Open registration (Public Beta)
- Mainnet Verifiability Path
- Jito BAM sidecar optimization
- Global Node Leaderboard
- Security Audit Phase 1
Phase 4: Sovereign Mesh
- Peer-to-Peer Data Sharding
- 5,000+ Hardware-Verified nodes
- TreePIR private information retrieval
- DAO Governance (MeshConfig)
- Production Mainnet Launch
Read the Full
Whitepaper
The complete technical and economic blueprint. Every architectural decision, every code snippet, and the full honest view of where we are today.