Web3 and stablecoin infrastructure
Web3 and stablecoin infrastructure
Web3 products run on a public blockchain plus the off-chain infrastructure that makes the chain usable: smart-contract CI, RPC and nodes, wallet back ends, indexers, IPFS, and dapp frontends. Quake AI is general-purpose IaaS, and these workloads run on the same Compute, storage, and network primitives as any other application you host here. This page sequences the layers, maps each to the primitives and templates behind it, and links to the deeper RPC and wallet leaves.
What this is for#
Run a complete Web3 stack on Quake AI: smart-contract development, RPC and blockchain nodes, wallet back ends, indexers, IPFS pinning, and dapp frontends. You bring the node and client software; Quake AI provides the Compute, Block and Object Storage, networking, and self-managed Postgres it runs on. Every pattern here runs CPU-only as a standard workload on general-purpose infrastructure, in US regions. Each layer below links to the leaf or how-to that covers it in depth.
Reference architecture#
Download diagram: SVG, PNG, and PDF.
One representative path runs from contract source to a live dapp. Each step links to the leaf or how-to that owns the detail; the bodies are not duplicated here.
-
Smart-contract CI. Run Hardhat or Foundry test suites and fork-from-mainnet runners on Compute, with build artifacts and fuzz corpora in Object Storage. The development environment template provides the runtime, and the DevOps automation leaf covers the CI pattern in general.
-
Self-hosted node. Run a
gethorrethEthereum node on a VM, with chain state on Block Storage and steady-state peer traffic over Network. The RPC and blockchain nodes leaf covers per-chain sizing, archive nodes, and the relationship to managed RPC providers. -
The Graph indexer. Ingest chain events into a self-managed Postgres store and serve GraphQL queries, with the indexer pointed at the node from step 2 or a managed RPC endpoint. Sizing follows The Graph's published indexer requirements.
-
IPFS pinning. Pin subgraph manifests, dapp assets, and metadata on an IPFS node, backed by Block Storage or Object Storage. The single VM template provides the runtime; flat egress keeps gateway traffic predictable.
-
Dapp frontend. Serve a static or server-rendered app on VMs or Kubernetes through an edge reverse proxy, with assets in Object Storage and a third-party CDN in front. The web applications and APIs leaf owns this shape.
Services involved#
| Service | Role in this architecture | Docs |
|---|---|---|
| Compute | CI runners, nodes, indexers, wallet back ends, IPFS, and dapp tiers (CPU) | Compute |
| Block Storage | Chain state for nodes and the indexer working set | Block Storage |
| Object Storage | Build artifacts, snapshots, and IPFS-pinned content | Object Storage |
| Network and self-managed edge | Public ingress, peer traffic, and request routing | Network |
| Self-managed Postgres | Subgraph store, wallet history, and analytics query layer | Self-managed PostgreSQL template |
Workload patterns and the primitives behind them#
Each pattern below maps to documented Quake AI primitives and a first-party template. None of these is a managed Web3 service: you run the node, indexer, wallet back end, or pinning node yourself on your own VMs and containers.
| Workload pattern | Quake AI primitives and templates | Docs |
|---|---|---|
| Smart-contract CI (Hardhat, Foundry, Anchor) | Compute and Object Storage; development environment template | Dev environment template |
RPC and blockchain nodes (geth, reth, Bitcoin) | Compute, Block Storage, Network, Object Storage; single VM and monitoring templates | RPC and blockchain nodes |
| Wallet back end (Tether WDK) | Compute, self-managed Postgres, Object Storage, API gateway | Wallet and payments back end |
| Indexing (The Graph subgraphs) | Compute, self-managed Postgres, Block Storage, IPFS | Self-managed Postgres template |
| IPFS pinning node | Compute, Block Storage, Object Storage, Network | Object Storage |
| Dapp frontend on VMs or Kubernetes | Compute, Object Storage, edge reverse proxy, Kubernetes | Web applications and APIs |
| DeFi keepers, liquidators, oracle feeders | Compute and monitoring; single VM template | Monitoring stack template |
| On-chain analytics back end | Compute, self-managed Postgres, Block Storage, Object Storage | Self-managed Postgres template |
Wallet and payments#
The wallet layer supports a client that holds its own keys. The Tether Wallet Development Kit is open-source and self-custodial, so the cloud surface is the supporting back end: an RPC dependency, a transaction-submission service, audit logging, and an indexed transaction history on self-managed Postgres. Rumble Wallet is the first real-world deployment of the WDK, launched with Tether on 07.01.2026 with USDT, XAUT, and BTC support. The Wallet and payments back end leaf covers this pattern in depth.
Get started#
- RPC and blockchain nodes: self-hosted Ethereum, Solana, and Bitcoin nodes, per-chain sizing, and the managed-RPC tradeoff.
- Wallet and payments back end: WDK wallet back ends, DeFi workers, and analytics, including the Tether and Rumble Wallet context.
- Web applications and APIs: dapp frontend hosting on VMs or Kubernetes.
- Dev environment template: OpenTofu pattern for a smart-contract CI runner.
- Self-managed Postgres template: the database tier behind an indexer or wallet back end.
- Object Storage: S3-compatible storage for build artifacts, snapshots, and pinned content.
- OpenTofu template library: validated IaC starting points for these patterns.
Estimate the cost#
Monthly cost estimate
Pricing calculator ↗Sized as a custom package on shared vCPU.
Monthly total for the required template above. Use the configurator below to add optional pieces and see the total update.
What each resource is for
Vm
s1a.small · 2 shared vCPU, 2 GiB RAM, 0.5 Gbps
Compute shown per role at custom-package rates ($29/dedicated vCPU, $7.25/shared vCPU, $1/GiB RAM). The headline above is the billed total: the cheaper of a named plan and the custom package, plus add-ons.
Included in baseline
s1a.small
2 shared vCPU, 2 GiB RAM, 0.5 Gbps
Compute + RAM rate basis
2 vCPU + 2 GiB RAM at $29/dedicated vCPU, $7.25/shared vCPU, $1/GiB RAM (regular). Totals apply the flat −$5/mo package promotion.
Block storage (20 GiB)
20 GiB at $0.08/GiB/mo
Public IP (included)
1 included with the custom package
Package promotional discount
Flat −$5.00/mo on the custom package (same promotion as named plans).
Included at no charge
These line items are zero on Quake AI. Many other providers meter them separately.
Data transfer (inbound and outbound)
Unlimited data transfer on every plan; Quake AI does not meter per-GB egress.
AWS, GCP, and Azure meter outbound transfer per GB. DigitalOcean and Hetzner include an allowance on compute plans, then charge overage.
Learn morePrivate networking
Private networks, subnets, Neutron routers, and security groups are included with the plan.
VPC objects are usually free to create elsewhere, but NAT gateways bill hourly plus per-GB processed. Quake AI uses router SNAT with no separate NAT line item.
Control-plane API requests
OpenStack API calls for provisioning and management are included.
Some managed services on other clouds meter API calls or charge for premium control-plane features.
Configure your estimate
Check the add-ons you plan to deploy to build a monthly total. Nothing is selected to start, so the total below begins at the baseline.
Starting template
The required baseline, always included.
Pricing data last validated: . For current rates, check quake.ai/pricing.
Considerations and limits#
- No managed blockchain, RPC, or wallet service. Quake AI supplies Compute, storage, and network primitives. You run the node software, indexer, wallet back end, and IPFS node yourself on your own VMs and containers.
- CPU only. Quake AI runs AMD EPYC instances with no GPU flavors. The patterns on this page are CPU workloads. GPU-accelerated zero-knowledge proving and similar workloads are not a fit.
- No managed database. The Graph indexer, wallet history, and analytics back ends run on self-managed Postgres. At The Graph's largest published tiers, a self-managed Postgres deployment is operationally heavy; most indexers run at the standard or medium tiers.
- No managed HSM. The WDK keeps custody on the client device. A wallet team that wants a remote-signer model brings its own HSM provider or self-manages software signing.
- No native CDN. Dapp assets sit in Object Storage behind a third-party CDN. See the CDN origin guide for the origin configuration.
- Block Storage throughput. Archive-node sync is bound by disk throughput. Quake AI documents Block Storage capacity and durability; measure sync time against representative volumes before committing to an archive node, and see the RPC and blockchain nodes leaf for per-chain detail. Per the
rethrelease notes, a baseline archive node starts at 2 TB of fast storage. - Flat egress, US regions. Quake AI uses a flat egress pricing model and three US regions with no automatic cross-region replication.
- Compliance posture. Quake AI holds SOC 2 Type I and Type II attestations, with SOC 3 on request. See Compliance and certifications. This page describes infrastructure patterns, not a regulated-workload attestation.
- Where the regulated hot path lives. Licensed stablecoin issuance and centralized-exchange hot-wallet hot paths sit under money-transmitter and banking-grade regimes beyond what SOC 2 and SOC 3 cover. The adjacent workloads (analytics, internal tooling, and frontends) run here; keep the regulated settlement hot path on a platform whose attestations meet your regulator's bar. A cross-chain bridge with attestation nodes across continents needs a footprint the three US regions do not provide, though its US-replica subset fits.