# DataPrism

> Documentation

## Docs

- [Architecture](/architecture): DataPrism combines client-side encryption, platform-managed object storage, and an on-chain
index. Users write the *encrypted index* of their files into **prisms** (on-chain namespaced
vaults) funded with **DPC** credits, while encrypted file shards are stored through short-lived,
project-scoped URLs. The system spans three layers, **smart contracts** on the blockchain,
off-chain **services** (API, storage, relayers), and the **client** (SDK + frontend).
- [Introduction](/intro): **DataPrism** is a privacy-first storage layer with client-side encryption, managed object
storage, and an on-chain index. It gives applications three core properties:
- [License](/license): The DataPrism smart contracts are released under the **Business Source License 1.1**
(BUSL-1.1).
- [Cryptography](/sdk/crypto): The crypto module is a **hybrid integrated-encryption scheme** (ephemeral key → ECDH →
HKDF-SHA256 → AEAD), built directly on `@noble/curves`, `@noble/ciphers`, and `@noble/hashes`.
It is the basis for sealing every encrypted prism slot. The central type is `DataPrismKey`.
- [Execution Layer](/sdk/execution): Every on-chain **write** goes through the execution layer, a single interface, `ExecutionLayer`,
with interchangeable implementations. The same application code works whether the user pays gas
(wallet) or a relayer fronts it (API).
- [File Pipeline](/sdk/files): The file pipeline is the SDK's implementation of [File Storage & Resilience](/concepts/file-pipeline).
It combines content-defined chunking, convergent encryption, Reed-Solomon erasure coding,
content-addressing (dedup), and a Merkle manifest (a compact on-chain index). The orchestrator
is `FilePipeline`.
- [Network & Client](/sdk/network): The SDK is built around two top-level objects: a **network** (which chain, which RPC, which
contract addresses) and the **client** facade that hangs everything off it.
- [SDK Overview](/sdk/overview): `@dataprism/sdk` is the **client-side core** of DataPrism, in TypeScript, embeddable anywhere
(browser, Node backend, or a script). It exposes a single API for three jobs:
- [Reading Data](/sdk/reading): All reads go through one or more **RPC** endpoints via `client.reader` (a `NetworkReader`).
They consume **no gas and no credits**. Reads target `DataPrismCloud` and the `Forwarder`
only, never the core `DataPrism` contract.
- [Cloud Standard](/sdk/standard): The standard module turns the [Cloud Standard slots](/concepts/prisms#the-cloud-standard) into
a typed codec. `CloudStandard` encodes and seals each slot; `CloudReader` reads and decrypts
them ([see Reading](/sdk/reading#decrypted-reads-cloudreader)); `PrismManager` orchestrates the
high-level prism lifecycle.
- [Storage Providers](/sdk/storage): Storage providers are the connectors to the object store where encrypted file shards live.
Applications use `ManagedStorageProvider`: DataPrism authorizes each operation with the current
user session and returns a short-lived signed URL. The SDK does not accept cloud credentials.
- [Relayer](/relayer/overview): `dataprism-relayer` is a continuously running Node.js service that submits user
meta-transactions on-chain. It polls the [API](/api/overview) for pending requests, checks
each one for profitability, submits it to `DataPrismCloudForwarder`, and reports the result
back to the API.
- [Contracts](/protocol/contracts): Reference for every contract in `dataprism-protocol`. For deployed addresses, see
[Deployments](/protocol/deployments).
- [Deployments](/protocol/deployments): The protocol is deployed on the **Sepolia** testnet. Addresses are recorded in
`scripts/deployments.json`.
- [Protocol Overview](/protocol/overview): `dataprism-protocol` contains the Solidity smart contracts that form the on-chain core of
DataPrism. Users own personal vaults (**prisms**) where they write, modify, and delete
arbitrary byte payloads, paying for each operation in the native **DPC** token.
- [Payment Relayer](/payment-relayer/overview): `dataprism-payment-relayer` bridges fiat card payments to on-chain DPC tokens. After a user
completes a Stripe payment on the [Frontend](/frontend/overview), this service buys DPC from
the [Exchange](/protocol/contracts#exchange) with USDC and transfers it to the user's wallet.
- [Frontend](/frontend/overview): `dataprism-frontend` is the **DataPrism Cloud** web dashboard. Users manage data projects,
storage, API keys, team members, and buy DPC tokens with a card (Stripe) or on-chain (USDC).
Authentication is wallet-based.
- [Credits & Payments](/concepts/credits): Every on-chain operation in DataPrism is paid for in **DPC**, the protocol's credit token.
This page explains what DPC is, how users acquire it, and how it funds a prism.
- [File Storage & Resilience](/concepts/file-pipeline): DataPrism accepts **any file, any size**. To do so it combines content-defined chunking,
convergent encryption, erasure coding, content-addressing, and managed object storage. The
result: storage only sees encrypted fragments, identical data is stored once, and missing
shards can be reconstructed when the configured quorum is available.
- [Prisms & the Cloud Standard](/concepts/prisms): A **prism** is an on-chain, namespaced vault dedicated to the **index** of your files (the
reconstruction "routes"), not to the files themselves. The heavy data lives at your cloud
providers; the prism only holds lightweight, encrypted, tamper-proof metadata.
- [Authentication](/api/authentication): The API uses four access levels.
- [Endpoints](/api/endpoints): All routes are served via AWS HTTP API Gateway. Responses are JSON. See
[Authentication](/api/authentication) for the storage, relayer, and admin schemes.
- [API Overview](/api/overview): `dataprism-api` is a serverless REST API for managed-storage authorization and gasless request
queueing. Signed-in users request short-lived storage URLs; users also submit EIP-712 requests
that relayers claim, process on-chain, and complete. The API does not submit blockchain
transactions directly.