One complete transaction — from GPU compute to fiat in the bank
A single, fully traced transaction showing how the Mesh Native Exchange ties the technical platform to a sustainable economic model. Every step is technically consistent and economically sound.
DOSFI Sovereignty — Closed Core / Open Surface
DOSFI Core is sovereign and closed. All educational content on this page is generated exclusively from open-surface materials — SDKs, ABIs, documentation, tutorials, examples, and conceptual explanations. Internal details of the DOSFI Runtime, Scheduler, Router, Readiness Engine, Privacy Model, Power/Thermal Model, Vital internals, DIU internals, MNE internals, and Mesh-Native App runtime internals are not revealed, described, or inferred.
No proprietary algorithms, system code, or architectural diagrams capable of enabling replication of the DOSFI Core are published. When internal logic is referenced, only high-level conceptual explanations are provided. DOSFI's sovereignty, mission-lock, and non-replicable architecture are preserved at all times.
Four participants, one loop
Installs DOSFI, earns Vital, spends Vital
Publishes the app Alice runs, receives settlement
Redeems accumulated Vital for fiat
Receives fiat via ACH / SWIFT / SEPA / FedWire / RTP
The full flow at a glance
Each step traced in full
Alice installs DOSFI
Alice downloads and installs the DOSFI mesh runtime on her GPU-equipped device.
Technical
- DOSFI runtime provisions a sovereign execution sandbox on Alice's device.
- A cryptographic node identity is generated and attested (NIST 800-63B tier 2+).
- The node registers with the mesh via the MNE discovery protocol.
- No private keys, internal scheduler logic, or closed-core modules are exposed — only the open-surface SDK participates.
Economic
No Vital is created at this step. The node is online but has not yet contributed compute.
Alice contributes GPU compute
Alice's device joins the mesh as an inference-capable node and begins executing WebGPU workloads dispatched by the routing layer.
Technical
- The node loads a WebGPU model and reports heartbeat freshness + latency telemetry.
- The mesh routing layer dispatches inference requests to Alice's node based on dispatch weight and reputation tier.
- Each completed inference produces a cryptographically signed compute proof.
- The node is now classified 'inference-capable' and visible across DOSFI, MeshInfer, and MNE with cross-system identity enabled.
Economic
Compute contribution is measured in signed inference hours. The mesh consensus verifies each proof before any Vital is issued.
Alice earns 2.3 Vital
After mesh consensus verifies Alice's accumulated compute proofs, 2.3 Vital (DIU) are issued to her wallet.
Technical
- Vital issuance is deterministic and compute-backed — each unit corresponds to a verified quantity of distributed intelligence output.
- Issuance is recorded on the internal settlement ledger with a cryptographic reference to the underlying compute proofs.
- Vital is non-speculative: it is not minted by a central authority at will, nor is it tradeable on any external market.
- The 2.3 Vital enters circulation only because real GPU compute was contributed and verified.
Economic
Vital supply increases by exactly 2.3 DIU. This is the only mechanism by which new Vital enters circulation — compute-backed issuance.
Alice spends 0.8 Vital running an app
Alice runs a mesh-native app (published by Bob). The app consumes routing, inference, and storage units. Alice's wallet is debited 0.8 Vital.
Technical
- The app's workflow engine meters usage across four dimensions: routing units, storage units, inference units, and compute credits.
- Each dimension has a deterministic, signed rate denominated in Vital (DIU).
- Alice's 0.8 Vital is consumed (destroyed) on spend — it is not transferred to Bob as the same token.
- A usage record is written to the settlement ledger referencing the app, the dimensions consumed, and the Vital amount.
Economic
Vital supply decreases by 0.8 DIU (consumed/destroyed). Alice's balance drops to 1.5 Vital. The consumption creates a settlement obligation — the app developer (Bob) is now owed 0.8 Vital for the usage his app generated.
Bob publishes the app
Bob, a verified developer, publishes the mesh-native app that Alice is running. The app is deployed as a mesh-native bundle with a signed manifest.
Technical
- Bob's developer identity (tier 3, hardware-key-bound) signs the app manifest.
- A PermissionManifest declares data access, routing requirements, inference requirements, and privacy constraints.
- The app passes automated security scanning and constitutional alignment checks.
- The app is published to the MNE marketplace with a versioned AppRelease record.
Economic
Publishing itself does not create or transfer Vital. It establishes Bob as the settlement recipient for all future usage of his app.
Bob receives settlement
The 0.8 Vital that Alice consumed generated a settlement obligation to the app developer. Bob's wallet is credited 0.8 Vital.
Technical
- The settlement runtime matches Alice's usage record to Bob's app and creates a SettlementRecord.
- Settlement is Vital-settled: 0.8 newly-issued Vital (DIU) are credited to Bob's wallet against the usage proof.
- This is not a transfer of Alice's consumed Vital — Alice's 0.8 was destroyed on spend. Bob's 0.8 is newly issued against the app-usage proof.
- The SettlementRecord status transitions: pending → settled → reconciled.
Economic
Vital supply increases by 0.8 DIU (developer settlement issuance). Net circulation is now 1.5 (Alice) + 0.8 (Bob) = 2.3 Vital — exactly the original compute-backed issuance. Conservation holds: no Vital was created without a backing proof.
Enterprise redeems Vital for fiat
An enterprise that has accumulated 1,000 Vital through its own compute contributions or app settlements initiates a bulk redemption to fiat.
Technical
- The enterprise initiates a RedemptionRecord with a Vital amount, target currency, and settlement rail.
- The redemption rate is locked at initiation — the enterprise knows exactly how much fiat it will receive.
- The 1,000 Vital is destroyed (removed from supply) on redemption. Vital is not transferred to the treasury — it is burned.
- The RedemptionRecord status transitions: initiated → processing → completed.
Economic
Vital supply decreases by 1,000 DIU (redeemed/destroyed). The enterprise's Vital balance drops to zero. A fiat disbursement obligation is created on the treasury side — fiat must now flow from the exchange treasury to the enterprise's bank account.
Fiat arrives in the bank account
The Mesh-Native Exchange treasury disburses fiat to the enterprise's bank account via the selected settlement rail (ACH, SWIFT, SEPA, FedWire, or RTP).
Technical
- The fiat settlement processor selects the rail based on the enterprise's counterparty and speed requirements.
- Fiat is transferred from the exchange's treasury account to the enterprise's bank account.
- The SettlementRecord is marked 'reconciled' once the bank confirms receipt.
- The entire flow is logged in the ComplianceAuditLog with full traceability from compute proof → Vital issuance → usage → settlement → redemption → fiat disbursement.
Economic
Fiat enters the enterprise's bank account from the exchange treasury. The cycle is complete: GPU compute → Vital → app usage → developer settlement → enterprise redemption → fiat in bank. The economic loop is closed and every unit is accounted for.
Ledger trace
Every Vital unit is accounted for at every stage. This ledger view shows the debit, credit, and running balance for each account across the full transaction. No Vital is created without a backing proof; no Vital disappears without a recorded event.
| Step | Account | Debit | Credit | Balance |
|---|---|---|---|---|
| 1 | Alice.mesh_node | — | node.online | node = active |
| 2 | Alice.compute_contribution | — | +2.3 Vital | Alice = 2.3 Vital |
| 3 | Alice.vital_wallet | — | 2.3 Vital | Alice = 2.3 Vital |
| 4 | Alice → App.usage | 0.8 Vital | — | Alice = 1.5 Vital |
| 4 | App.developer_pool | — | +0.8 Vital | Bob = 0.8 Vital |
| 5 | Bob.app_published | — | app.live | App = published |
| 6 | Bob.vital_wallet | — | 0.8 Vital | Bob = 0.8 Vital |
| 7 | Enterprise.redemption | 1,000 Vital | — | Enterprise = 0 Vital |
| 8 | Enterprise.bank_account | — | +$ fiat | Bank = settled |
Conservation of Vital
The single most important property of the Vital economy: supply is conserved. Vital is created only against a verified proof (compute or app-usage) and destroyed on spend or redemption. At no point in this transaction does the net circulation exceed the total compute-backed issuance.
Created only against verified GPU inference proof
Destroyed on spend — not transferred to Bob as the same token
Newly issued to Bob against app usage proof, not Alice's token
Alice's remaining balance + Bob's settlement = original issuance
Destroyed on redemption — removed from supply
New fiat enters enterprise bank account from treasury
Who verifies the compute?
"Cryptographic proof" is the claim — but who checks it? The answer is five independent layers, each with a different trust root: TEE hardware attestation, redundant execution, scheduler verification, mesh consensus, and adversarial challenge-response. No single party can issue Vital; all five must agree.
All of them — in layers
No single party verifies compute. Verification is distributed across five layers — hardware, redundant peers, the scheduler, consensus, and adversarial challenge — each catching what the others might miss. This is defense-in-depth: the security of the economy does not rest on any one verifier, because any one verifier can be compromised.
TEE Hardware Attestation
The GPU proves itself
The GPU runs inside a Trusted Execution Environment (NVIDIA Confidential Computing, AMD SEV-SNP, or Intel TDX). The TEE produces a hardware-signed attestation proving the inference code ran unmodified on real silicon. This is the hardware root of trust — the proof originates from the physical GPU, not from software the node controls.
Fake hardware, software tampering, model substitution
Silicon-level (hardware key in the GPU)
Redundant Execution
Nodes check each other
The same inference request is dispatched to N redundant nodes (default N=3). Results are compared by consensus within a tolerance band. Matching results confirm the computation. Divergent results trigger dispute resolution — the outlier is flagged, its proof is rejected, and its reputation is downgraded.
Incorrect computation, collusion (if <N nodes collude), hallucinated results
Economic (redundant independent nodes)
Scheduler Verification
The workflow is checked
The scheduler records the dispatch, the expected output shape, and the actual returned output. It flags anomalies: too-fast responses (suspicious — may not have run real compute), too-slow responses (degraded quality), and output-shape mismatches. The scheduler's log is signed and submitted as part of the proof chain.
Pre-computed cached answers, timing attacks, output format spoofing
Operational (scheduler audit log)
Mesh Consensus
The network confirms before issuance
The full proof chain — TEE attestation + redundant result agreement + scheduler log — is submitted to mesh consensus. Consensus nodes verify the chain cryptographically and record it on the ledger. Vital is issued only after consensus confirmation. No single party can force issuance; the network must agree the proof is valid.
Forged proofs, replay attacks, single-party coercion
Distributed (consensus quorum)
Challenge-Response
Proofs can be re-verified at any time
Any node can challenge any compute proof at any time after issuance. The challenged node must reproduce the computation or provide the intermediate execution state. If it cannot, the proof is invalidated, the issued Vital is clawed back, and the node's reputation is slashed. This makes verification ongoing, not just at-issuance.
Post-issuance fraud, state corruption, long-term collusion
Adversarial (any node can challenge)
The proof chain (what gets submitted)
Each component is cryptographically signed by its originator. The chain is immutable — remove any link and the proof is invalid. Vital issuance requires the complete chain; no partial proofs are accepted.
Why five layers instead of one
The security foundation
The economy is backed by compute, and the compute is verified by five independent trust roots. No single party — not the scheduler, not consensus, not the hardware, not the redundant nodes — can unilaterally issue Vital. Issuance requires all five layers to agree. This is what makes "compute-backed" a verifiable claim rather than a promise: the proof chain is the security, and the proof chain has no single point of failure.
What determines issuance?
"Compute-backed" is not a hand-wave. Vital issuance is determined by an explicit, public, deterministic equation with six factors. Every factor is verifiable, every value is signed, and the same equation applies to every node, every contribution, every time.
Issuance equation (compute → Vital)
Where V is in milliseconds; dividing by 1000 converts to GPU-seconds. The product of B × Q × H × R × P yields DIU per GPU-second for this specific contribution. Multiply by verified GPU-seconds to get total DIU issued.
Raw GPU inference execution time in milliseconds, verified by mesh consensus via cryptographic compute proof. Only verified ms count — unverified or disputed execution is excluded.
The platform constant that converts verified compute time into DIU at baseline. 1 DIU is issued per 1,000 verified GPU-seconds at baseline multipliers.
Multiplier based on inference output validation. The requesting app validates the result; correct, useful output scores higher. Failed or low-quality inference scores lower.
Multiplier based on GPU tier. Consumer GPU = 1.0, workstation GPU = 1.5, data-center GPU = 2.0. Reflects real compute capacity contributed, not just time.
Multiplier based on node reputation tier. Bronze = 0.8, Silver = 1.0, Gold = 1.2, Platinum = 1.5. Rewards reliable, well-behaved nodes with longer uptime and clean audit history.
Multiplier based on the privacy tier of the workload. Standard = 1.0, Confidential = 1.25, Sovereign = 1.5. Higher privacy workloads are scarcer and more valuable.
Worked example: Alice's 2.3 Vital
If Alice had a Gold reputation (R = 1.2) and a workstation GPU (H = 1.5), the same 2,300,000 verified ms would yield 2.3 × 1.2 × 1.5 = 4.14 Vital. The equation rewards better hardware and reliability — not just raw time.
Consumption equation (app usage → Vital spent)
App usage is metered across four dimensions, each with a deterministic, signed rate. The total Vital consumed is the sum across all dimensions. Rates are public, versioned, and signed by the platform — no hidden multipliers.
Mesh routing requests dispatched on behalf of the app.
Persistent storage allocated and retained by the app.
Inference executions consumed by the app across mesh nodes.
General-purpose compute credits for custom workloads.
Why this is verifiable and fair
Why is Bob's settlement newly issued?
Alice's 0.8 is burned on spend. Bob receives a newly issued 0.8 — not Alice's original tokens. Why mint new instead of routing Alice's 0.8 through settlement? The answer is an architectural choice called burn-and-mint, and it exists for six concrete reasons a direct transfer cannot satisfy.
The design choice
Alice's 0.8 is burned on spend. Bob receives a newly issued 0.8 against the app-usage proof — not Alice's original tokens. This is a deliberate architectural choice called burn-and-mint, and it exists for six concrete reasons that a direct transfer model cannot satisfy.
Decoupling consumption from settlement
Alice's spend and Bob's settlement are independent events. They can happen at different times, in different amounts, and with different verification. A transfer couples them tightly — Bob only gets paid exactly when Alice spends, exactly what Alice spends. Burn-and-mint lets the platform aggregate, batch, delay, and adjust settlements independently.
No custodial intermediary
A transfer requires holding Alice's 0.8 somewhere between burn and receipt — an escrow, pool, or custodial wallet. That creates custody risk, regulatory exposure, and a single point of failure. Burn-and-mint eliminates custody entirely: nothing is held. The unit is destroyed; a new unit is created against a fresh proof.
Independent proof chains
Alice's burn is backed by a consumption proof (she used the app). Bob's mint is backed by a settlement proof (his app was used). These are different proofs with different verification criteria. Coupling them means a failure in one chain breaks the other. Burn-and-mint keeps the proof chains independent and fault-isolated.
Batching & aggregation
In practice, thousands of users consume an app. Bob doesn't want thousands of micro-transfers. Burn-and-mint lets the platform aggregate all usage, verify it, and issue a single batched settlement. A transfer model forces per-spend movement or a custodial aggregator.
Privacy separation
A transfer links Alice and Bob directly on the ledger. Burn-and-mint records Alice's consumption and Bob's settlement as separate events, linked only by a settlement reference — not by a direct token movement. Better for privacy and regulatory design.
Economic policy flexibility
The burn rate and mint rate don't have to be 1:1. A settlement fee (burn 0.8, mint 0.75 to Bob, 0.05 to treasury) is just a parameter in issuance. With a transfer, applying a fee requires intercepting the transfer — which means custody.
Transfer vs. burn-and-mint
| Aspect | Direct transfer | Burn-and-mint |
|---|---|---|
| What happens to Alice's 0.8 | Held in escrow / pool, then forwarded | Destroyed immediately against consumption proof |
| What Bob receives | Alice's original 0.8 tokens | Newly issued 0.8 against settlement proof |
| Custody required | Yes — escrow between burn and receipt | No — nothing is held |
| Settlement timing | Coupled to each individual spend | Batched and settled independently |
| Fee application | Requires intercepting the transfer | Parameter in settlement issuance |
| Fault tolerance | Failed transfer leaves stuck funds | Burn and mint retry independently |
| Privacy | Ledger shows Alice → Bob directly | Linked by settlement reference, not token transfer |
| Supply conservation | No change on spend | Burn then mint — net zero, conserved |
The core architectural insight
Burn-and-mint decouples consumption from settlement, eliminating the custodial intermediary that a transfer model requires. The 0.8 Alice burns and the 0.8 Bob receives are not the same tokens — they are two independent events backed by two independent proofs, settled at independent times. This is what enables batching, fee application, fault tolerance, and privacy without ever holding someone else's funds. The supply stays balanced not because tokens are routed, but because every mint is backed by a proof and every burn is recorded — the conservation is a property of the ledger, not of a transfer path.
Where does the treasury's fiat come from?
Step 8 says "the exchange treasury disburses fiat." But every redemption system ultimately depends on a sustainable source of fiat. The treasury is not a magic reservoir — it is funded by real fiat payments from enterprises and banks who receive real platform services in return. Here is exactly how.
The core principle
The treasury is funded by fiat inflows from enterprises and banks who pay for platform services. Vital is the internal settlement unit that tracks who contributed compute and who is owed fiat. The fiat itself comes from real customers paying real money for real services — subscriptions, compute contracts, fees, and service agreements. Every Vital redemption is backed by fiat that was deposited by a paying customer.
Enterprise subscriptions
Enterprises pay monthly subscriptions for platform access — Enterprise Plan ($2,500/mo) and Bank Plan ($10,000–$25,000/mo). This is recurring fiat revenue deposited directly into the treasury.
Compute purchases
Enterprises that need more compute than their own nodes contribute purchase compute contracts. They pay fiat for compute credits, which the platform uses to honor Vital redemptions from compute contributors.
Platform & transaction fees
A percentage of each settlement and redemption is retained as a platform fee. This covers rail costs, compliance overhead, and treasury operations.
Service contracts
Banks and enterprises pay for SLA-backed service contracts, compliance reporting exports, premium rail access, and dedicated support. These are fiat-denominated contracts billed on a quarterly or annual basis.
The balanced loop
Enterprises and banks pay fiat for subscriptions, compute contracts, fees, and service contracts. This fiat is deposited into the exchange treasury and held as reserves.
Compute contributors (like Alice) and developers (like Bob) redeem their earned Vital for fiat. The treasury disburses fiat via banking rails (ACH, SWIFT, SEPA, FedWire, RTP).
Fiat paid in by enterprises ≈ fiat paid out to compute contributors, plus platform operating margin. Vital is the internal accounting unit that tracks the obligation between the two sides. The treasury never disburses fiat it doesn't hold — redemptions are honored from reserves funded by real customer payments.
Why this is sustainable
Three properties that make the loop sustainable
No Vital without proof
Every Vital unit in circulation traces back to a cryptographically signed compute proof or app-usage proof. There is no discretionary minting. Supply grows only when real distributed intelligence is produced.
Earned, spent, redeemed — never traded
Vital cannot be bought, sold, or traded on any external market. It is earned by contributing compute, spent by running apps, and redeemed to fiat by enterprises. This eliminates speculative dynamics and keeps Vital tied to real compute output.
Every unit traceable end-to-end
From compute proof → Vital issuance → app usage → developer settlement → enterprise redemption → fiat disbursement, every transition is logged in the ComplianceAuditLog with a cryptographic reference. Regulators and auditors can trace any unit's full lifecycle.
The loop is closed
GPU compute → Vital → app usage → developer settlement → enterprise redemption → fiat in bank. Every step is technically consistent (cryptographic proofs, deterministic rates, signed ledgers) and economically sound (compute-backed issuance, conservation of supply, non-speculative by design). This is how the Mesh Native Exchange ties the technical platform to a sustainable economic model.