Best Base RPC providers for onchain applications in 2026

Introduction

Base has become the dominant L2 production environment in 2026 — ranking as the #1 EVM chain by DeFi TVL after Ethereum, with about $6.3B locked across roughly 900 protocols and about $5.2B in stablecoins (DefiLlama, October 2026). As Base’s adoption across stablecoin platforms, DeFi protocols, and AI agent deployments grows, selecting among Base RPC providers is no longer a minor infrastructure choice — it’s a core architectural decision.

A note on Base’s evolving stack: Base moved off the OP Stack node software in 2026. Since the Azul upgrade (May 28, 2026), nodes run Base’s own base/base stack (base-reth-node and base-consensus). Chain ID 8453, the standard RPC methods and the optimism_ namespace are unchanged, and Base still describes itself as OP-Stack-spec compatible. This guide focuses on present-day provider selection.

The starting point every production team should know: Base’s public RPC endpoints are explicitly rate-limited and marked “not for production” in the official documentation, making the choice of a third-party provider non-negotiable for any serious workload. Beyond that, Base’s current architecture introduces two infrastructure considerations that go beyond typical L1 or L2 thinking. First, OP Stack defines two distinct failure classes often misread as “RPC is down” — sequencer downtime (block height freezes, no new transactions) and transaction submission outages (sequencer runs but struggles to publish to L1, affecting safe/finalized status). A good RPC provider can’t fix these, but it can make incidents survivable. Second, Flashblocks — Base’s 200ms preconfirmation layer — has redefined what fast confirmation means on Base, and providers must support it correctly through both HTTP and WebSocket to be viable for time-critical applications.

In this benchmark, we compare the best Base RPC providers for 2026 across latency, uptime, throughput, pricing structure, and security posture — mapped to the three core use cases: stablecoin infrastructure, DeFi protocols, and AI agents. The comparison includes real benchmark data from Chainstack’s Compare Dashboard with method-level performance across EU, JP, and US West regions.

Base RPC providers comparison 2026

When evaluating Base RPC providers, teams should look beyond headline uptime claims and instead benchmark method-level performance, billing transparency, and Flashblocks implementation quality:

Provider	Free Plan	Pricing Model	Uptime / SLA	Dev Experience	Compliance
Chainstack	3M req/mo, ~25 RPS	Request Units (1 RU standard, 2 RU archive)	99.9% quarterly SLA with service credits (Enterprise); 99.99%+ measured availability	Dashboard metrics, IP/origin access rules, archive, testnet faucets, Chainbench, Compare Dashboard	SOC 2 Type II
RouteMesh	Free community endpoint (reads)	Premium: $3–$6 per 1M calls (economy/performance routing)	No formal SLA; daily sync + replay correctness checks	Routes across 16–20 upstream providers per method, automatic failover	Not published (routing layer)
Dwellir	20 responses/s, 100k responses/day	1 credit per response, no CU weighting; Developer $49, Growth $299, Scale $999; Unlimited Nodes from $119/mo	99.99% SLA on dedicated clusters (custom terms); public status page	Trace/debug on paid plans, HTTP + WebSocket, Flashblocks documented, archive endpoints, dedicated cluster $3,366/mo, crypto payments	Not published (no SOC 2 / ISO 27001 found)
dRPC	210M CU/30 days (public nodes)	Flat-rate: 20 CU/request, $6 per 1M requests	High availability via multi-provider routing; no formal public SLA	Simple setup, OpenAI-compatible API, public status page, key control, front-end protection	No public SOC 2
Ankr	200M credits/mo, ~30 RPS	PAYG: $0.10 = 1M credits; EVM methods 200 credits flat	99.99% uptime claimed; avg 56ms response time	Basic dashboard, multi-chain support (40+ chains, EVM + non-EVM), HTTPS & WebSocket, archive	SOC 2 Type II (held by operator; report under NDA), ISO 27001 in progress
Alchemy	30M CUs/mo, ~15 RPS (300 CU/s)	Compute Units by method weight; PAYG + monthly	99.99% uptime claimed during peak; SLA formally on Enterprise	Webhooks (Notify), Gas Manager, Bundler, Token/NFT/Transfers APIs, Debug API, real-time analytics dashboard, SDK support	SOC 2 Type II
Quicknode	Trial only (10M credits)	API credits (method-weighted; e.g. eth_call = 20 credits on Base)	99.99% uptime stated on its security page; premium SLA on Enterprise	Streams, Webhooks, OP-Node API, Trace API, marketplace add-ons (incl. DeFi integrations), team dashboards	SOC 2 Type II + ISO 27001

Choose the right Base RPC providers by use case

Different Base RPC providers perform differently depending on workload profile — stablecoin settlement, DeFi indexing, and AI-driven automation each stress infrastructure in distinct ways.

Stablecoin settlement and payment infrastructure

Stablecoin platforms on Base run continuous, unforgiving pipelines — every payment, redemption, and treasury rebalance depends on infrastructure that simply doesn’t go down. Even brief outages cascade into failed settlements, reconciliation gaps, and user-facing errors that erode trust fast.

The Base-specific risk to plan for is sequencer downtime, which is distinct from an RPC provider failure. When it happens, transactions can’t be submitted through the normal path regardless of how good your provider is — so payment architectures need built-in grace periods and pause logic to handle it gracefully. On the upside, Flashblocks’ 200ms preconfirmations give stablecoin UIs faster transaction feedback than waiting for the standard 2-second block, meaningfully improving the payment experience.

For this use case: prioritize providers with flat or request-unit billing (volume spikes shouldn’t surprise your finance team), stable WebSocket connections for real-time confirmation flows, and 99.99%+ uptime with multi-region failover.

DeFi Protocols

Base’s DeFi landscape is anchored by lending markets (Morpho, Aave), major DEXs (Aerodrome, Uniswap), and a growing derivatives layer — all of which place heavy, continuous read demands on RPC infrastructure. During volatility, every protocol queries simultaneously: positions checked, prices updated, liquidity rebalanced. Shared RPC endpoints degrade exactly when your protocol needs them most. Dedicated Nodes eliminate this risk — your infrastructure doesn’t share resources with anyone else, so response times stay consistent whether the market is quiet or in freefall. For lending protocols where stale data or a delayed liquidation has direct financial consequences, that consistency is a business requirement, not a performance optimization.

Beyond real-time performance, DeFi protocols need deep historical access for incident investigation, risk modeling, and compliance reporting. Archive data and transaction tracing should be part of your provider selection from day one, not an upgrade you retrofit after an incident.

For this use case: Dedicated Nodes for performance isolation during peak market conditions, archive access, and a provider with proven tail latency rather than just marketing averages.

AI agents on Base

Base has become a primary home for onchain AI agents in 2026 — from Coinbase’s AgentKit-powered bots to autonomous DeFi strategies and LLM-orchestrated onchain workflows. Agent workloads expose two infrastructure problems that don’t show up in standard benchmarks: billing unpredictability and WebSocket reliability. Agents generate autonomous, bursty request patterns that are hard to forecast — credit-weighted pricing models can produce invoices that make agent economics unworkable, while a dropped event subscription means a missed liquidation or a failed keeper action.

Chainstack is purpose-built for this. Nodes are spec-compliant and expose standardized endpoints that any LLM can connect to out of the box — from OpenAI GPT and Anthropic Claude to Google Gemini, DeepSeek, and compact local models. MCP support ships in two forms: an RPC MCP server for all supported chains, and a Developer Portal MCP server so agents can autonomously ingest best practices and apply them to on-chain operations. For simulation-heavy agent architectures, full forking and call simulation is available out of the box. And the RU pricing model — 1 RU per standard call, 2 RU per archive or debug call — makes cost scaling predictable as agent volume grows, with no method-weight surprises.

For this use case: flat-rate or request-unit billing, high RPS headroom for burst windows, stable WebSocket infrastructure, and Flashblocks support.

In-depth Base RPC providers analysis

Below, we take a closer look at how individual Base RPC providers perform in real-world production environments, including latency consistency, scalability, and operational reliability.

Chainstack

What makes Chainstack stand out for Base is how much is available from the same console:

• Global Nodes for geo-balanced Base RPC access across US, EU, and APAC.
• Dedicated Nodes for isolated performance and full control over node configuration — worth it when tail latency consistency matters.
• Archive nodes for full historical data from genesis, including debug and trace queries.
• Optimized Submission on Global Nodes — private, optimized transaction routing designed to reduce inclusion delays; off on a new node until you enable it from the node’s Add-ons tab.
• Self-Hosted deployment (Base-Reth + Base-Node) for teams that need the node inside their own infrastructure perimeter.
• Unlimited Node add-on for flat monthly pricing with no request limits — useful for workloads with unpredictable burst windows.
• Base developer tooling with Base APIs, testnet faucet, and step-by-step development guides covering setup, deployment, and production best practices.
• MCP support for AI agent integrations — compatible with any LLM out of the box.

All of this adds up to a Base setup that covers nearly every use case. Whether you’re building stablecoin infrastructure, DeFi protocols, or AI agent backends, Chainstack gives you reliable performance, clear pricing, and infrastructure to scale with.

🤖 You can also access Chainstack Base RPC directly from Claude, Cursor, Codex, Windsurf, Gemini CLI, GitHub Copilot, Antigravity, Claude.ai, or ChatGPT using Chainstack MCP. Learn more about Chainstack MCP, or see the Chainstack Agents page for the fuller agent stack.

	Details
Pricing	Developer — free, 3M req/mo (~25 RPS). Growth — $49/mo, 20M req (~250 RPS). Pro — $199/mo, 80M req (~400 RPS). Business — $499/mo, 200M req (~600 RPS). Enterprise — from $990/mo, 400M+ req, custom RPS. Unlimited Node add-on from $149/mo flat. Dedicated Nodes — from $0.50/hr per node plus storage, Pro plan and up. Crypto payments accepted.
Billing model	Request Units: 1 RU per full node call, 2 RU per archive call. No method-weight multipliers.
Uptime / SLA	Enterprise SLA document: 99.9% quarterly uptime commitment with service credits. Measured availability on Global/Dedicated lines: 99.99%+. Public status page available.
Security	SOC 2 Type II (December 2025) and ISO 27001 (July 2026) certified. Security materials accessible via security page.
Flashblocks	Supported on Base Mainnet and Sepolia.
Archive / debug	Full archive from genesis, plus debug and trace methods, on paid plans (Growth and up); not on the free Developer plan.

For enterprise: SOC 2 Type II and ISO 27001 artifacts are available, access controls are production-grade, and managed upgrades eliminate the hard-fork timestamp divergence risk. The distinction between the contractual SLA (99.9% quarterly, with service credits) and the measured availability (99.99%+) is worth noting for vendor risk documentation — both figures exist and serve different purposes.

Pros: Transparent RU billing, Flashblocks support, Unlimited Node add-on, full archive + debug/trace, SOC 2 Type II and ISO 27001, access controls, 70+ chains, crypto payments. Cons: Fixed RPS per tier (ultra-high-frequency apps may need Dedicated); free tier tight for indexers/bots; Dedicated Nodes require at least Pro plan; Ultra-high-frequency trading systems requiring custom node-level tuning may prefer fully self-hosted or bespoke infrastructure configurations.

RouteMesh

RouteMesh is an RPC aggregation and routing layer rather than a node operator — it routes requests across 15+ upstream providers, including Chainstack, with real-time health scoring and automatic failover. RouteMesh confirms full support for Base.

Pricing is split between a free community endpoint (read requests routed to public nodes, transaction sends routed to premium infrastructure) and a Premium tier priced $3-$6 per million calls depending on routing strategy. For teams that want redundancy without managing multiple provider relationships, RouteMesh’s automatic failover across many upstream operators is the pitch.

Pros: Automatic failover across many upstream providers, low p50 latency on reads, no vendor lock-in. Cons: No formal SLA; archive depth and debug/trace availability depend on whichever upstream serves a given request rather than being a property you configure directly.

Dwellir

Dwellir is a Swedish RPC provider with a long Polkadot track record that now serves 150+ networks, Base among them. For Base it offers a managed API over HTTPS and WebSocket with trace and debug methods on paid plans, and dedicated archive clusters for teams that need isolated, unmetered access. Its Base page documents Flashblocks support (the pending tag plus newFlashblocks, newFlashblockTransactions, and pendingLogs WebSocket streams) and its Base endpoints run archive nodes; we did not benchmark it here, so test it against your own workload.

Shared plans bill one credit per response with no compute-unit weighting, so eth_getLogs and debug_traceTransaction cost the same as eth_blockNumber. That makes monthly cost easy to model for DeFi and agent workloads whose method mix shifts over time. You can also pay in crypto.

	Details
Pricing	Free — 20 responses/second, 100,000 responses per day. Developer — $49/mo, 25M responses, 100 responses/second. Growth — $299/mo, 150M responses, 500/second, eth_getLogs over up to 10,000 blocks. Scale — $999/mo, 500M responses, 5,000/second. Unlimited Nodes from $119/mo flat (25–1,000 RPS). A dedicated Base archive cluster is listed at $3,366/mo. Pricing checked October 9, 2026.
Billing model	One credit per response, no method-weight multipliers.
Uptime / SLA	99.99% uptime SLA on dedicated clusters with custom terms. No SLA figure found for shared plans; public status page available.
Security	No SOC 2 or ISO 27001 attestation found on its public pricing and dedicated-cluster pages.
Flashblocks	Documented on Dwellir’s Base page (pending tag, newFlashblocks WebSocket stream, eth_sendRawTransactionSync); not benchmarked in this article.
Archive / trace	Base endpoints run archive nodes; trace and debug APIs on paid plans.

Pros: Flat per-response billing (no method surprises), trace and debug on paid plans, flat-rate Unlimited Nodes and dedicated archive clusters in one account, crypto payments. Cons: No SOC 2 or ISO 27001 attestation found; free tier capped at 100,000 responses per day; the Base dedicated cluster is listed at $3,366/month; not part of the benchmark below.

dRPC

dRPC takes a different architectural approach: rather than running its own node infrastructure, it aggregates across 60+ providers in 8 geo-clusters, routing traffic intelligently to optimize availability and performance. Base mainnet and Sepolia are available, and dRPC is named in Base’s Flashblocks documentation as a Flashblocks-enabled provider.

The most significant development for cost planning: in 2025, dRPC moved to flat-rate method pricing — 20 CU per request regardless of method, at $6 per 1M requests. This eliminates the “pricing trap” that makes debug_traceTransaction and eth_getLogs expensive surprises in credit-weighted models. For DeFi teams doing heavy log queries or trace-based analytics, this is a meaningful advantage.

	Details
Pricing	Free — 210M CU/30 days (public nodes only). Paid — PAYG with deposit, flat-rate: 20 CU per request, $6 per 1M requests. Private endpoints and additional features (fallback, verification) on paid tier. “Go unlimited” option available.
Billing model	Flat-rate per request — no method-weight multipliers. Predictable cost regardless of call composition.
Uptime / SLA	High availability through multi-provider routing. Public status page available (Base mainnet and Sepolia listed as components). No formal published SLA.
Security	No publicly documented SOC 2 certification at time of writing.
Flashblocks	Available through aggregated Base endpoints.
Multi-provider routing	Reduces risk from individual upstream provider degradation — but does not eliminate OP Stack L2 failure classes (sequencer downtime, L1 publication issues).

Important nuance on reliability: dRPC’s aggregation reduces the risk of a single upstream provider degrading your service, but this is distinct from L2-level reliability. Sequencer downtime and safe/finalized discrepancies are OP Stack characteristics that exist at a layer above any RPC provider’s routing logic. The correct framing: dRPC reduces upstream-provider risk, not L2 protocol risk.

Pros: Flat-rate pricing (no method surprises), most generous free tier, multi-provider redundancy, public status page, no vendor lock-in. Cons: No formal SLA; no SOC 2 certification; enterprise compliance features depend on specific contract terms; performance consistency varies across distributed provider network.

Ankr

Ankr provides Base access through a globally distributed network of node operators, with Base mainnet and Sepolia available over HTTPS and WebSocket (WebSocket and trace/debug are Premium-plan features).

For multi-chain teams adding Base to an existing stack that already includes other EVM and non-EVM networks, Ankr’s breadth (40+ chains) and consistent API surface lower the integration overhead compared to managing separate providers per chain.

	Details
Pricing	Free — 200M credits/mo (~30 RPS). Premium — PAYG at $0.10 per 1M credits; EVM methods flat at 200 API credits each. Enterprise — custom SLA, region orchestration, dedicated infrastructure.
Billing model	API credits; EVM methods uniformly 200 credits (simpler than variable CU weights, but still credit-based).
Uptime / SLA	99.99% uptime and 56ms avg response time publicly stated. Enterprise plan includes custom SLA.
Security	SOC 2 Type II held by Ankr’s operating entity (audit report available under NDA); ISO 27001 listed as in progress. Verify current status in Ankr’s trust center before using it in vendor risk documentation.
Flashblocks	Flashblocks methods are documented in Ankr’s Base docs (pending tag on eth_getBlockByNumber, eth_getBalance and eth_getTransactionCount, plus preconfirmed receipts).
Archive	Full and archive access available.

On SOC 2 status: Ankr’s operating entity holds SOC 2 Type II (the audit report is shared under NDA), while ISO 27001 is listed as in progress. For enterprise vendor risk documentation, confirm current certification status directly with Ankr’s trust center rather than relying on this article.

Pros: 200M free credits/mo, publicly stated performance metrics (56ms / 99.99%), HTTP + WSS + archive, 40+ chains including non-EVM, flexible PAYG. Cons: ISO 27001 still in progress and SOC 2 Type II report only under NDA (verify current status); advanced analytics/support gated to paid; performance can vary across distributed nodes; no flat-rate unlimited option.

Alchemy

Alchemy functions as a developer platform that extends well beyond raw RPC. For Base specifically, it is listed as an official node provider in Base documentation and publishes a Flashblocks quickstart covering pending block logic for key methods — reducing integration friction for teams adding preconfirmation to existing applications without changing API surface.

The platform’s strongest differentiation for DeFi workloads is tooling depth: Notify for event webhooks, transaction APIs for sending and tracking transactions, a Debug API for tracing, and real-time analytics dashboards. Teams building liquidation bots, MEV searchers, or event-driven settlement systems will find Alchemy’s extended APIs genuinely useful.

	Details
Pricing	Free — 30M CUs/mo (~15 RPS, 300 CU/s). Pay-as-you-go — $0.525 per 1M CUs (from 300 RPS). Enterprise — custom with volume discounts. Different methods have different CU weights (heavier calls cost more).
Billing model	Compute Units: method-weighted. Bill depends on call composition, not just volume. Requires tracking method mix for accurate budget modeling.
Uptime / SLA	99.99% uptime claimed during peak market conditions; global infrastructure with automatic failover. Formal SLA on Enterprise plans.
Security	SOC 2 Type II certified; public trust center available.
Flashblocks	Flashblocks API quickstart published; accessible through existing Alchemy Base RPC.
Archive / debug	Available; specifics depend on plan tier.

On OP Stack and sequencer risk: Alchemy’s Flashblocks integration and rich dev tooling are strong, but sequencer risks don’t disappear at the RPC layer. Protocols using Alchemy should still design fallback logic and pause mechanisms for sequencer downtime — the infrastructure doesn’t abstract away OP Stack’s operational characteristics.

Pros: SOC 2 Type II, Webhooks/Gas Manager/Bundler APIs, Debug API, Flashblocks quickstart, 40+ chains, rich analytics. Cons: CU pricing requires careful method-mix tracking; billing less predictable at scale than flat request models; very high RPS requires Enterprise plan; dedicated capacity (Dedicated Clusters) is sales-gated, not self-serve.

Quicknode

Quicknode‘s Base infrastructure is among the most complete from an OP Stack-awareness perspective. Its documentation explicitly covers Flashblocks (“partial block updates every 200ms, up to 10× faster than the standard 2-second block”), Trace API, OP-Node API (for rollup-specific objects and diagnostics), and event streaming via Streams and Webhooks. For DeFi teams that need real-time data feeds as an architectural pattern rather than just request-response endpoints, Quicknode’s ecosystem is hard to match.

The platform handles enormous volume — hundreds of billions of requests per month across its network — and states 99.99% uptime across supported services on its security page and offers a premium SLA on Enterprise, with dedicated clusters available for isolated enterprise workloads.

	Details
Pricing	Build — $49/mo, 80M credits, 50 RPS. Accelerate — $249/mo, 450M credits, 125 RPS. Scale — $499/mo, 950M credits, 250 RPS. Business — $999/mo, 2B credits, 500 RPS. Enterprise — custom. Credits do not roll over. Note: eth_call on Base = 20 credits — method-weighting matters significantly for DeFi workloads.
Billing model	API credits, method-weighted. Call composition directly affects cost.
Uptime / SLA	99.99% uptime stated on its security page; premium SLA on Enterprise.
Security	SOC 2 Type II + SOC 1 Type 2 + ISO 27001.
Flashblocks	Full documentation with examples; supported natively.
OP Stack-specific	OP-Node API, Trace API, Flashblocks docs all available.

For DeFi teams specifically: the method-weighted credit model means eth_call and eth_getLogs — the two methods that typically dominate DeFi workloads — consume credits faster. Benchmarking your actual call composition against the credit pricing table before committing to a plan is strongly recommended.

Pros: 99.99% uptime stated, premium Enterprise SLA, SOC 2 Type II + ISO 27001, Flashblocks, OP-Node API, Trace API, Streams/Webhooks, 500+ RPS at scale, archive access. Cons: No free tier (trial only); method-weighted credits make long-term cost modeling complex; no flat-rate unlimited option for burst-heavy workloads.

Real-world performance benchmark on Base

Provider scores (lower is better)

Metrics collected included average response latency and request success rate per method. All providers were tested within the same 30-minute timeframe to ensure comparable network conditions.

Performance metrics may vary depending on network congestion, market volatility, regional traffic spikes, and provider-side scaling events. The results reflect relative performance during the measured window rather than absolute guarantees under all conditions.

Dedicated and Enterprise-tier infrastructure were not included in this benchmark.

Response time by API method — key findings

The method-level breakdown reveals differences that matter significantly for Base production workloads:

• eth_getLogs — Quicknode showed substantially higher response times (~1.5–2s range) compared to Chainstack, Alchemy, and dRPC on this method. For DeFi protocols where log scanning is a core operation (event indexing, liquidation triggers, settlement confirmation), this gap is operationally significant.
• eth_subscribe — dRPC showed the highest latency on WebSocket subscriptions (~2s), which matters for any application relying on real-time event streams rather than polling.
• eth_call, eth_getBalance, eth_blockNumber — All providers performed comparably on these lighter methods, with differences in the sub-100ms range.
• debug_traceTransaction, debug_traceBlockByNumber — Chainstack and Alchemy led on trace methods, relevant for DeFi incident analysis and compliance workflows.

What this means by use case

• For stablecoin and payment flows — dominated by eth_call (balance checks) and eth_getTransactionReceipt (confirmation) — all four providers perform comparably. The overall score difference between Chainstack (0.38) and Alchemy (0.40) is minimal at this method profile.
• For DeFi protocols — where eth_getLogs and eth_subscribe drive a significant portion of traffic — Chainstack and Alchemy pull ahead meaningfully. Quicknode’s eth_getLogs latency and dRPC’s eth_subscribe latency are worth testing against your specific workload before committing.
• For archive and trace-heavy workloads (analytics, incident response, compliance reporting) — Chainstack’s advantage on debug/trace methods is consistent across regions.

These results illustrate how Base RPC providers diverge under real production method mixes rather than synthetic single-method testing.

Methodology note: Scores reflect growth-tier plan benchmarks across EU, JP, and US West. Enterprise or Dedicated tier performance will differ — dedicated infrastructure typically shows lower tail latency and more consistent p95/p99 than shared endpoints. Run provider-specific benchmarks using the Chainstack Compare Dashboard against your actual method mix before finalizing infrastructure decisions.

Conclusion: choosing the right Base RPC providers

For Base in 2026, choosing between Base RPC providers means selecting the infrastructure layer that will quietly determine your system’s reliability, cost predictability, and upgrade resilience.

Base’s dominance as the leading L2 (#1 EVM chain by TVL after Ethereum) means the stakes for infrastructure decisions are higher than ever. Stablecoin platforms need WSS stability and sequencer monitoring. DeFi protocols need tail latency control and honest cost modeling under peak load. AI agents need flat-rate billing, high RPS headroom for burst windows, and stable WebSocket connections for event-driven execution.

Chainstack covers all three — predictable request-unit pricing, SOC 2 Type II and ISO 27001, full archive and debug access, Flashblocks support, and managed infrastructure that handles Base upgrades on your behalf. For teams where Base infrastructure is foundational rather than incidental, it’s the most complete option in 2026.

FAQ

Related Reading

• Flashblocks on Base: 200ms preconfirmations for lightning-fast UX
• How to get a Base public RPC endpoint
• Best Ethereum RPC providers in 2026
• Base: Deploy an ERC-721 contract with Hardhat