Ecosystem Synced·11 Articles7 Rules5 Actions5 Continuity Plans0 Supra-Signals
End-to-End Transaction Walkthrough

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.

The Cast

Four participants, one loop

Alice
Compute contributor & app user

Installs DOSFI, earns Vital, spends Vital

Bob
Mesh-native app developer

Publishes the app Alice runs, receives settlement

Enterprise
Bulk Vital accumulator

Redeems accumulated Vital for fiat

Bank
Fiat settlement counterparty

Receives fiat via ACH / SWIFT / SEPA / FedWire / RTP

Overview

The full flow at a glance

Step 1Alice
Installs DOSFI
Mesh runtime provisioned
Step 2Alice
Contributes GPU compute
WebGPU node joins mesh
Step 3Alice
Earns 2.3 Vital
Compute-backed issuance
Step 4Alice
Spends 0.8 Vital
Runs mesh-native app
Step 5Bob
Publishes the app
Mesh-native bundle deployed
Step 6Bob
Receives settlement
Vital settled to developer
Step 7Enterprise
Redeems Vital for fiat
Accumulated Vital → fiat
Step 8Bank
Fiat arrives
ACH / SWIFT / SEPA / RTP
Step by Step

Each step traced in full

Step 1Alice

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.

Vital Δ0 Vital
Alice0 Vital
Step 2Alice

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.

Vital Δ0 Vital (pending verification)
Alice0 Vital
Step 3Alice

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.

Vital Δ+2.3 Vital
Alice2.3 Vital
Step 4Alice

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.

Vital Δ−0.8 Vital (consumed)
Alice1.5 Vital
Step 5Bob

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.

Vital Δ0 Vital
Bob0 Vital
Step 6Bob

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.

Vital Δ+0.8 Vital (to Bob)
Bob0.8 Vital
Step 7Enterprise

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.

Vital Δ−1,000 Vital (destroyed)
Enterprise0 Vital
Step 8Bank

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.

Vital Δ0 Vital (fiat side)
Banksettled + reconciled
Double-Entry View

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.

StepAccountDebitCreditBalance
1Alice.mesh_node—node.onlinenode = active
2Alice.compute_contribution—+2.3 VitalAlice = 2.3 Vital
3Alice.vital_wallet—2.3 VitalAlice = 2.3 Vital
4Alice → App.usage0.8 Vital—Alice = 1.5 Vital
4App.developer_pool—+0.8 VitalBob = 0.8 Vital
5Bob.app_published—app.liveApp = published
6Bob.vital_wallet—0.8 VitalBob = 0.8 Vital
7Enterprise.redemption1,000 Vital—Enterprise = 0 Vital
8Enterprise.bank_account—+$ fiatBank = settled
Economic Soundness

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.

Vital issued (compute-backed)2.3 Vital

Created only against verified GPU inference proof

Vital consumed (app usage)0.8 Vital

Destroyed on spend — not transferred to Bob as the same token

Vital issued to developer (settlement)0.8 Vital

Newly issued to Bob against app usage proof, not Alice's token

Net Vital in circulation1.5 + 0.8 = 2.3 Vital

Alice's remaining balance + Bob's settlement = original issuance

Vital redeemed (enterprise)1,000 Vital

Destroyed on redemption — removed from supply

Fiat disbursed$ at locked rate

New fiat enters enterprise bank account from treasury

Verification Architecture

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.

Layer 1

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.

Catches

Fake hardware, software tampering, model substitution

Trust root

Silicon-level (hardware key in the GPU)

Layer 2

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.

Catches

Incorrect computation, collusion (if <N nodes collude), hallucinated results

Trust root

Economic (redundant independent nodes)

Layer 3

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.

Catches

Pre-computed cached answers, timing attacks, output format spoofing

Trust root

Operational (scheduler audit log)

Layer 4

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.

Catches

Forged proofs, replay attacks, single-party coercion

Trust root

Distributed (consensus quorum)

Layer 5

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.

Catches

Post-issuance fraud, state corruption, long-term collusion

Trust root

Adversarial (any node can challenge)

The proof chain (what gets submitted)

Proof=TEE_attestation+redundant_result_hashes+scheduler_log+consensus_confirmation

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

A TEE alone can be compromised if the hardware vendor is coerced — redundant execution catches this.
Redundant execution fails if all N nodes collude — the scheduler's timing analysis catches suspiciously uniform responses.
The scheduler can be compromised — consensus requires a quorum of independent verifiers to confirm.
Consensus can be captured — challenge-response lets any single honest node re-verify and invalidate a fraudulent proof post-issuance.
Each layer's trust root is different: hardware, economic, operational, distributed, and adversarial. Compromising all five simultaneously requires subverting silicon, economics, operations, a quorum, and an adversarial challenger at the same time.

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.

The Metering Equation

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)

DIU_issued=(V / 1000)×B×Q×H×R×P

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.

V
Verified GPU millisecondsmeasured

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.

Alice's value: 2,300,000 ms
B
Base DIU rate0.001 DIU / GPU-second

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.

Alice's value: 0.001
Q
Quality factor0.8 – 1.2

Multiplier based on inference output validation. The requesting app validates the result; correct, useful output scores higher. Failed or low-quality inference scores lower.

Alice's value: 1.0 (standard)
H
Hardware class0.5 – 2.0

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.

Alice's value: 1.0 (consumer)
R
Reputation multiplier0.8 – 1.5

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.

Alice's value: 1.0 (silver)
P
Privacy tier multiplier1.0 – 1.5

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.

Alice's value: 1.0 (standard)

Worked example: Alice's 2.3 Vital

Substitute Alice's values:
DIU = (2,300,000 ms / 1000) × 0.001 × 1.0 × 1.0 × 1.0 × 1.0
Simplify:
DIU = 2,300 GPU-seconds × 0.001 DIU/GPU-second × 1.0
Result:
DIU = 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)

Vital_consumed=(Ru × R_rate)+(Su × S_rate)+(Iu × I_rate)+(Cc × C_rate)

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.

Ru
Routing units0.001 DIU / unit

Mesh routing requests dispatched on behalf of the app.

Su
Storage units0.0001 DIU / unit·hr

Persistent storage allocated and retained by the app.

Iu
Inference units0.01 DIU / unit

Inference executions consumed by the app across mesh nodes.

Cc
Compute credits0.005 DIU / credit

General-purpose compute credits for custom workloads.

Why this is verifiable and fair

Every factor is public, deterministic, and signed — no discretionary adjustments.
Verified GPU milliseconds are backed by cryptographic compute proofs that mesh consensus checks before issuance.
Hardware class is attested from the node's runtime capabilities, not self-reported.
Reputation tier is derived from on-chain audit history (uptime, dispute rate, attestation status).
Quality factor is determined by the requesting app's validation of the inference output — the consumer of the compute judges its quality.
The same equation applies to every node, every contribution, every time — no special cases.
Architectural Design Choice

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

AspectDirect transferBurn-and-mint
What happens to Alice's 0.8Held in escrow / pool, then forwardedDestroyed immediately against consumption proof
What Bob receivesAlice's original 0.8 tokensNewly issued 0.8 against settlement proof
Custody requiredYes — escrow between burn and receiptNo — nothing is held
Settlement timingCoupled to each individual spendBatched and settled independently
Fee applicationRequires intercepting the transferParameter in settlement issuance
Fault toleranceFailed transfer leaves stuck fundsBurn and mint retry independently
PrivacyLedger shows Alice → Bob directlyLinked by settlement reference, not token transfer
Supply conservationNo change on spendBurn 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.

The Unanswered Question

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.

Example: $2,500/mo × 40 enterprises = $100,000/mo

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.

Example: $50,000 compute contract → 50,000 compute credits

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.

Example: 0.5% of redemption volume

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.

Example: $100,000/yr SLA contract

The balanced loop

Fiat in → Treasury

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.

Treasury → Fiat out

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

The balance

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

Every fiat disbursement is backed by a prior fiat deposit — no fiat is created from nothing.
Enterprises pay because they receive real value: platform access, compute capacity, compliance, and SLA-backed service.
Compute contributors receive fiat because they provided real value: verified GPU inference that enterprises consumed.
The platform retains a margin (subscription + fees) that covers operations, compliance, and rail costs.
If enterprise demand for compute grows, treasury inflows grow, enabling more redemptions — the system scales with real demand, not speculation.
Why This Works

Three properties that make the loop sustainable

1 · Compute-Backed

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.

2 · Non-Speculative

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.

3 · Fully Auditable

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.

Compute-backed ✓Conserved ✓Non-speculative ✓Auditable ✓Fiat-settled ✓