Crust Network is a purpose-built layer 1 blockchain that provides decentralized cloud storage by adding an incentive and service layer to IPFS. It is designed for developers and builders who need verifiable, persistent, and cost-effective storage for dApps, NFTs, websites, and other Web3 content.
If you are evaluating Crust for your project, the key decision is whether you need a decentralized storage layer at all, and if so, how to integrate it with your existing stack. This article explains what Crust is, how it works, and how to connect to it via RPC endpoints.
Quick Recommendation: When to Use Crust Network
Crust is a strong fit when you need:
- Permanent or flexible storage for NFT metadata, dApp content, or website hosting.
- IPFS compatibility with an incentive layer that ensures data availability and redundancy.
- Cross-chain interoperability to store data from multiple blockchains (EVM, Substrate, etc.).
If your use case is simple pinning of a few files, you might start with a centralized service. But if you need verifiable, decentralized storage with on-chain guarantees, Crust is worth considering.
For developers, the next step is to set up an RPC connection to interact with the Crust chain. You can use a managed RPC provider like OnFinality to get reliable endpoints without running your own node.
How Crust Network Works
Crust is built on Substrate, the same framework used by Polkadot. It uses a unique consensus mechanism called GPoS (Guaranteed Proof of Stake) that combines staking with storage proofs. Storage nodes prove they are storing data correctly using MPoW (Meaningful Proof of Work) and TEE (Trusted Execution Environment) technology.
The network has three main components:
- Validators: Secure the chain and validate transactions.
- Storage providers: Offer disk space and prove they store data.
- Gateway providers: Provide access to stored data via IPFS gateways.
Crust's storage market is on-chain, meaning users can order storage and pay with the native CRU token. The network also supports cross-chain storage via XCMP (Cross-Chain Message Passing) and EVM compatibility, making it accessible from Ethereum, Polygon, and other chains.
Key Features of Crust Network
IPFS Integration
Crust uses IPFS as its underlying storage protocol. Files are addressed by content ID (CID), and Crust adds an incentive layer to ensure that files are pinned and replicated across multiple nodes. This means you get the benefits of IPFS (content addressing, deduplication) with the guarantee that your data will persist.
On-Chain Storage Market
Users can place storage orders on the Crust blockchain. The network matches orders with storage providers, and the data is stored with redundancy (typically 30+ replicas). This creates a permissionless market where anyone can offer storage and earn CRU.
Cross-Chain Interoperability
Crust supports multiple ways to interact with other chains:
- EVM: Crust has an EVM-compatible layer, so you can deploy Solidity smart contracts.
- XCMP: As a Polkadot parachain, Crust can communicate with other Substrate-based chains.
- X-Chain Contracts: Smart contracts that allow storage functions to be called from other chains.
Tools and SDKs
Crust provides several tools for developers:
- Crust Files: A personal cloud storage interface for Web3.
- IPFS W3Auth Gateway: A Web3-authenticated IPFS gateway supporting all IPFS write operations.
- IPFS W3Auth Pinning Service: A standard IPFS pinning service with Web3 authentication.
- Crust GitHub Action: For decentralized CI/CD hosting via IPFS pinning.
Crust Network vs. Other Storage Solutions
| Feature | Crust Network | Filecoin | Arweave |
|---|---|---|---|
| Underlying protocol | IPFS | IPFS | Custom |
| Consensus | GPoS (Substrate) | Proof-of-Spacetime | Proof-of-Access |
| Storage payment | On-chain market (CRU) | On-chain market (FIL) | Upfront payment |
| Cross-chain | EVM, XCMP | Bridges | Bridges |
| Data persistence | Incentivized pinning | Incentivized storage | Permanent |
Crust is often compared to Filecoin and Arweave. While Filecoin also uses IPFS, Crust's integration with Substrate and its EVM compatibility make it easier to use from Polkadot and Ethereum ecosystems. Arweave offers permanent storage with a one-time fee, but Crust provides more flexibility with its storage market.
Getting Started with Crust Network RPC
To interact with the Crust blockchain, you need an RPC endpoint. You can run your own node, but for most developers, using a managed RPC provider is more practical. OnFinality offers public and dedicated RPC endpoints for Crust, allowing you to focus on building your application.
Public RPC Endpoint
OnFinality provides a public endpoint for Crust:
https://rpc.crust.network
You can use this endpoint to send JSON-RPC requests to the Crust chain. For example, to get the latest block number:
curl -X POST https://rpc.crust.network \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"chain_getHeader","params":[],"id":1}'
This will return the latest block header, including the block number.
Using the Polkadot.js API
For Substrate-based chains like Crust, you can use the Polkadot.js API to interact with the chain. Here's an example of connecting to Crust and reading the chain name:
const { ApiPromise, WsProvider } = require('@polkadot/api');
async function main() {
const provider = new WsProvider('wss://rpc.crust.network');
const api = await ApiPromise.create({ provider });
const chain = await api.rpc.system.chain();
console.log('Chain:', chain.toString());
await api.disconnect();
}
main().catch(console.error);
Wallet Configuration
If you want to use Crust with a wallet like SubWallet, you can add the network manually. The chain ID for Crust is crab (or crust for mainnet). Here's an example configuration:
{
"network": "crust",
"displayName": "Crust Network",
"rpc": "https://rpc.crust.network",
"ws": "wss://rpc.crust.network",
"chainId": "0x0000000000000000000000000000000000000000000000000000000000000000",
"explorer": "https://crust.subscan.io"
}
Note: The chain ID is a placeholder; you should check the official documentation for the correct value.
Common Use Cases for Crust Network
NFT Metadata Storage
NFTs often need metadata that persists forever. Crust can store NFT metadata on IPFS with on-chain guarantees, ensuring that the metadata remains accessible even if the original minter disappears.
Website Hosting
You can host a fully decentralized website on Crust. By pinning your site's files to IPFS via Crust, you ensure that the site is always available, with no single point of failure.
dApp Data Storage
Many dApps need to store user-generated content, such as messages, profiles, or documents. Crust provides a decentralized alternative to traditional cloud storage, with the added benefit of verifiable data integrity.
Data Archiving
For long-term data retention, Crust's storage market allows you to pay for storage over time, with the option to renew. This is useful for compliance or archival purposes.
How to Choose an RPC Provider for Crust
When selecting an RPC provider for Crust, consider the following:
- Reliability: Look for providers with a track record of uptime and performance.
- Scalability: Ensure the provider can handle your expected request volume.
- Support: Check if the provider offers dedicated nodes for high-throughput workloads.
- Pricing: Compare pricing models, especially if you have high usage.
OnFinality offers both shared and dedicated RPC nodes for Crust. You can start with the free public endpoint and upgrade to a dedicated node if your project grows. For more details, see our RPC pricing page.
Troubleshooting Common RPC Issues
Connection Timeouts
If you experience timeouts, check your network connection and ensure you are using the correct endpoint. Public endpoints can be rate-limited; consider using a dedicated node for production.
Invalid Chain ID
When connecting to Crust, ensure you use the correct chain ID. For Crust mainnet, the chain ID is crab (or crust). Using the wrong ID will result in connection errors.
WebSocket vs. HTTPS
Some operations require WebSocket (e.g., subscriptions). Use wss:// for WebSocket connections and https:// for HTTPS. Both are available on the public endpoint.
Key Takeaways
- Crust Network is a Substrate-based layer 1 blockchain that provides decentralized storage by adding an incentive layer to IPFS.
- It offers an on-chain storage market, cross-chain interoperability, and tools for developers.
- Crust is suitable for NFT metadata, website hosting, dApp data, and archiving.
- To interact with Crust, you need an RPC endpoint. OnFinality provides reliable public and dedicated endpoints.
- When choosing an RPC provider, consider reliability, scalability, support, and pricing.
Frequently Asked Questions
What is Crust Network used for?
Crust Network is used for decentralized storage, providing an incentive layer for IPFS. It is commonly used for NFT metadata, website hosting, and dApp data storage.
Is Crust Network a Polkadot parachain?
Yes, Crust is built on Substrate and is a parachain in the Polkadot ecosystem. It also has EVM compatibility, allowing interaction with Ethereum-based chains.
How does Crust Network ensure data availability?
Crust uses a combination of MPoW (Meaningful Proof of Work) and TEE (Trusted Execution Environment) to prove that storage nodes are actually storing the data. The network also replicates data across multiple nodes (typically 30+ replicas).
How do I get a Crust RPC endpoint?
You can use the public endpoint https://rpc.crust.network or get a dedicated endpoint from a provider like OnFinality. For more options, see our supported networks page.
What is the CRU token used for?
CRU is the native token of Crust Network. It is used to pay for storage orders, stake for consensus, and participate in governance.
Can I use Crust with Ethereum?
Yes, Crust has EVM compatibility, so you can interact with it using Ethereum tools and smart contracts. You can also use cross-chain bridges to store data from Ethereum.
Is Crust Network free to use?
There is a cost to store data on Crust, paid in CRU. However, you can use the public RPC endpoint for free to interact with the chain. For high-volume usage, consider a paid RPC plan.
How does Crust compare to Filecoin?
Both Crust and Filecoin use IPFS and provide decentralized storage. Crust is built on Substrate and has EVM compatibility, while Filecoin has its own blockchain. Crust may be easier to integrate with Polkadot and Ethereum ecosystems.
What are the system requirements for running a Crust node?
Running a Crust node requires a machine with sufficient storage and bandwidth. For most developers, using a managed RPC provider is more practical. See our dedicated node page for more information.
How do I monitor my Crust RPC usage?
If you use OnFinality, you can monitor your usage through the dashboard. For custom monitoring, you can use tools like Prometheus to track request metrics.
For more information about Crust Network and RPC services, visit our network page and RPC pricing page.
Related resources
Originally published at OnFinality.
Top comments (0)