How the Model Works
Each phase is enforced at protocol level: author in plain English or Solidity, score every non-deterministic edge, then finalize with validator-held 2FA shards.
Author & Generate
Teams describe intent in natural language. The compiler emits bytecode plus human-readable clauses, invariants, and tests. Guardrails block unsafe patterns and surface missing checks before deployment.
Score & Simulate
The AI oracle simulates calls to external APIs, price feeds, and off-chain software. It publishes a safety grade per route (A–F) with rationale, traceability, and fallback actions.
Enforce & Finalize
Runtime execution remains deterministic. Non-deterministic inputs must attach their score and provenance. Validators enforce quorum-signed 2FA; counterparties can reject interactions below their risk appetite.
Architecture Pillars
Bytecode with Guardrails
Contracts compile to a deterministic VM. Static analysis ensures bounded loops, explicit error handling, and consistent state updates before bytecode is accepted.
Scored Oracle Routes
Every API/market read is routed through a scoring service that logs provider, timestamp, variance, and Monte Carlo stress tests. Trusted sources (e.g., NYSE feeds, CoinGecko, government open-data APIs) inherit higher baseline confidence; riskier endpoints get throttled or rejected. Scores become part of the transaction metadata.
Validator-Sharded 2FA
Even if a signing key leaks, the transaction cannot clear without validator quorum approval. Shards rotate; compromised keys trigger rapid shard re-issuance and circuit-breakers.
Safety Grades
Grades are attached to calls, cached on-chain, and consumable by wallets, dApps, and counterparties.
| Grade | Meaning | Common Triggers |
|---|---|---|
| A | Deterministic or redundant data sources with historical stability | On-chain price feeds, multi-API quorum with agreement, deterministic math paths |
| B | Minor variance observed; mitigations in place | Single API with signed attestations, cached responses, time-bound windows |
| C | Non-deterministic input accepted with guardrails | Volatile market reads, user-supplied params with caps, simulation divergence <5% |
| D | High variance; consumer must opt-in | Illiquid feeds, large slippage tolerance, external compute with limited proofs |
| F | Rejected | Unverifiable source, tamper signals, timeout or replay risk detected |
Our source registry ranks inherently trustworthy venues—major exchanges (e.g., NYSE), curated crypto aggregators (e.g., CoinGecko), and government sites—so high-signal feeds start with higher confidence while fringe or unverifiable sources get downgraded by default.
Developer Workflow
Tooling
- Natural-language contract authoring with inline linting and invariant suggestions.
- One-click test generation plus fuzzing against probabilistic inputs.
- Risk-grade preview before deployment; publish grade + rationale alongside ABI.
Operational Controls
- Auto circuit-breakers on score downgrade or oracle divergence.
- Timelocked upgrades with validator co-sign and public rollback plans.
- On-chain changelog that links human-readable clauses to bytecode diffs.
Build & Deploy on QP
Contracts compile to QP’s V1 EVM-compatible runtime and are gated by validator-sharded 2FA before execution. We publish a safety grade alongside ABI + bytecode so integrators can set risk thresholds.
Write Solidity (QRC)
Use Solidity with QRC conventions (ERC-aligned interfaces). Compile to bytecode with your preferred toolchain and export ABI + bytecode bundle.
Check Determinism
Submit bytecode to the QP contract checker node to validate size limits, opcode rules, and deterministic execution constraints.
Deploy with Shard Approval
Deploy transactions include shard quorum approval. Once signed, the contract is written to the chain and indexed in QuantumScan.
Quick Token Builder
Launch a QRC meme or community token with taxes, splits, and media—all from a guided builder.
Manage Deploys, Reviews, and Queues
All contract submissions run through the QP checker node, then enter a deploy queue once shard quorum is confirmed.
Connect Required
Deploys require a connected QP wallet and shard approval.
0 Pending
Bytecode validation + determinism checks before deploy.
—
Recent contracts appear here after approval.
Recent Activity
| Contract | Status | Last Update |
|---|---|---|
| — | Awaiting submissions | — |
Deploy payloads are prepared in the dashboard and submitted after shard quorum approval.
Run-Time Guarantees
Deterministic Execution
All state transitions are repeatable; probabilistic branches must attach the oracle decision and score so nodes can reproduce and audit.
Chain of Custody
Each external call stores provider, latency, variance band, and signer. Counterparties can refuse to interact if custody is missing.
2FA Finalization
Validator shards co-sign transactions and contract deployments. Shard rotation policy prevents long-tail accumulation of risk.
Shard Signing Diagram
ED25519 signatures remain standard, but every transaction must also pass shard quorum before execution and ledger update.
Shard fragments are derived from the user’s key and split into validator-specific parts. One authoritative validator and the online validator set each receive only their own shard slice; no single node can reconstruct the key. A quorum of shard approvals is required before the transaction is accepted.
Assets: Tokens vs NFTs
Fungible (Tokens)
- Standardized mint/burn with circuit-breakers on score downgrades.
- Router API exposes `price`, `quote`, `swap`, and `state` for bonded-curve pairs.
- Supply changes are co-signed by validator shards; treasury moves require 2FA quorum.
Non-Fungible (NFTs)
- Immutable media links with optional content hashing for tamper checks.
- Royalty + split payouts are scored when using external price/metadata feeds.
- Transfers can require shard concurrence for high-value collections.
API & Publishing Overview
Core APIs
- Node REST: `/dex/state`, `/dex/quote`, `/dex/lastPrice`, `/support/message`.
- Contract deploy: submit ABI + bytecode + human-readable clauses for grading.
- Event hooks: webhooks or SSE for grade changes, oracle divergence, and breaker trips.
Publishing Flow
- Author in English or Solidity; generate guarded bytecode and tests.
- Attach risk sources (oracles, caps, invariants); request a grade.
- Validator-sharded 2FA co-signs the deploy; publish ABI + grade.
- List token/NFT in router (if fungible) or registry (if NFT); expose docs in the explorer.
Build on QP
Launch contracts with transparent risk grades and quantum-safe protection.