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.
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.
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.