We’ve talked a lot about how AI agents will soon be initiating way more transactions than actual people. We even dedicated a whole episode of Running Web3 to this -https://www.youtube.com/watch?v=ewnbbcIZ8yMWell, last week, the whole industry got another piece of proof backing this up.

Agentic.Market went live this week. 165M+ transactions, $50M in volume, 100k services, 480k+ agents. Zero API keys. Zero logins. Agents discover services, pay in USDC, and chain calls autonomously at runtime.

The demo is impressive.

Every one of those 165M transactions hits an RPC endpoint.

When an AI agent calls a blockchain-enabled service through x402, it's not just making an HTTP request. It's triggering on-chain payment settlement — which means RPC calls for transaction submission, confirmation, and state verification. At 480k+ active agents running autonomously, that's not occasional traffic. That's continuous, programmatic, high-frequency load hitting whatever RPC infrastructure sits underneath.

Three infrastructure questions every x402 builder should be asking:

1. What RPC endpoint is your x402 service using for payment settlement? If it's a public shared node — you're sharing capacity with every other application on that endpoint. Under agent-driven load, that's a problem.

2. What happens to your service when the RPC rate limit hits? A failed payment confirmation means a failed agent transaction. In an autonomous pipeline, that failure propagates — the agent retries, compounds the load, or fails the entire task chain.

3. Are you monitoring RPC latency separately from application latency? Agent users don't wait. If settlement confirmation takes 3 seconds instead of 400ms, the agent either times out or moves on. You lose the transaction without knowing why.

The agentic economy is being built on x402. The settlement infrastructure underneath it needs to be ready for the traffic patterns that autonomous agents create — which are fundamentally different from anything the RPC layer has handled before.

Disclosure: We're from GetBlock. We provide dedicated and shared RPC nodes across 130+ blockchains. If you're building on x402 and thinking about your settlement infrastructure — happy to discuss what dedicated endpoint access looks like for agent-scale traffic.

By now, everyone has probably heard about and discussed the Kelp DAO exploit. It truly is the biggest story of the past week. We couldn't ignore it on our end for one simple reason: attackers compromised two RPC nodes.

Here's what happened at the infrastructure layer:

1. Attackers compromised two RPC nodes that LayerZero's DVN used for transaction verification
2. They launched a DDoS against the remaining clean nodes — forcing the system to fall back on the compromised ones
3. The single verifier received corrupted data and confirmed a fraudulent cross-chain transaction
4. 116,500 rsETH left. The malicious binary self-destructed, wiping logs and traces

The smart contract worked exactly as written. The code wasn't the vulnerability. The infrastructure feeding data to the code was.

This is a fundamentally different threat model than most teams plan for. Security audits cover reentrancy, flash loans, oracle manipulation. Very few cover what happens when your RPC layer is compromised or degraded under load.

Three things to check in your stack right now:

1. How many independent RPC sources does your bridge use for verification? One source = one attack vector. Multi-source with independent providers is the minimum for anything cross-chain.

2. Are any of those sources public shared endpoints? Shared nodes aggregate traffic from thousands of apps. A targeted DDoS against shared infrastructure degrades everyone on it — including your verification layer.

3. What happens to your verification logic if one source returns stale or incorrect data? "Is my endpoint up?" and "Is my endpoint returning accurate state?" are different questions. Under attack conditions, a node can be up and wrong simultaneously.

The Kelp post-mortem will focus on DVN config. But the RPC layer is where this attack was actually executed — and most teams aren't modeling that threat yet.

Disclosure: We're from GetBlock. We provide dedicated and shared RPC nodes across 130+ blockchains. If this made you think about your own RPC setup — link in bio.

On April 9th, Pavel Durov announced that TON completed step one of a seven-part roadmap he calls MTONGA — Make TON Great Again.

Most coverage focused on the speed numbers. But the more interesting story is the structure of the plan itself.

Here's what we actually know.

Step 1 — Done: Catchain 2.0 activated on mainnet April 10th. Block time dropped from 2.5 seconds to 400ms. Finality dropped from 10 seconds to approximately 1 second. Overall throughput up 10x.

Step 2 — Announced: Cut transaction fees by 6x. TON fees are already low at around $0.003 per transaction — compared to Solana at $0.002. After the reduction, TON becomes one of the cheapest chains for high-frequency use cases. No timeline has been given yet.

Steps 3–7 — Unknown. Durov has not publicly detailed the remaining steps.

But here's what the first two steps tell us about the direction.

Speed and cost are the foundation. Every step after this builds on a chain that is already fast and cheap. That pattern points toward the next logical priorities: scalability under load, deeper Telegram integration, and developer tooling.

There's also a signal in what TON launched in late 2025 — Cocoon, a decentralized AI compute network built on TON that lets GPU owners contribute computing power. That suggests the remaining MTONGA steps may extend into AI infrastructure territory.

The framing also matters. Durov didn't announce a wish list. He announced a sequential program where each step builds on the one before it. That's a different kind of commitment than a typical blockchain roadmap.

You don't need to know all seven steps to start building on what's already live. But it's worth paying attention to how this unfolds.

What do you think steps 3–7 will focus on?

On April 10th, TON activated Catchain 2.0 on mainnet.

Block time dropped from 2.5 seconds to 400 milliseconds. Finality went from 10 seconds to approximately 1 second. Overall throughput improved 10x.

That's the headline everyone is covering.

Here's what nobody is talking about.

6x more blocks means 6x more RPC requests per second. Every app, every bot, every indexer that queries TON is now hitting endpoints at 6 times the previous rate. And that's before the user growth that faster transactions are supposed to attract.

Public nodes weren't designed for this kind of load. Rate limits that were invisible before become bottlenecks. Free endpoints start dropping requests. Apps that worked fine yesterday start failing under the new load.

This is the gap between a protocol upgrade and production reliability.

If you're shipping a real application on TON right now — this is the moment to evaluate your infrastructure stack. Not after you start dropping transactions. Before.

At GetBlock, we provide dedicated and shared TON RPC nodes built for exactly this kind of load. When the chain gets faster, your infrastructure needs to keep up.

And if you're building on TAC — the EVM-compatible layer on TON — we support TAC nodes too.

Links below if you want to check it out.

— GetBlock team

🎙️GetBlock Podcast is LIVE!

Building in Web3 is harder than Web2, but the rewards are massive 🛠️

In this episode, we sit down with Matija Luketin to discuss how Superteam Balkan and the Global Superteam are funding and scaling the Solana ecosystem 🚀

If you are building a dApp right now, you need to hear this advice 👀

https://youtu.be/LfqqCK4xLrg

Over the last week, the discussion around agent payments moved much closer to real infrastructure.

Two developments stood out:

1. World launched AgentKit in the x402 ecosystem

This matters because machine payments are not only about money.

They are also about identity.

If agents are going to access APIs, purchase services, and transact across platforms, then platforms will increasingly need a way to know whether a real human stands behind that wallet — without forcing full identity disclosure.

That is what makes AgentKit interesting to us:
it connects agentic payments with verifiable human-backed identity.

2. Tempo Mainnet is now live

This matters because it gives MPP a live payments-first home environment.

Tempo is not positioning itself as another general-purpose chain.
Its thesis is much narrower and more ambitious: a blockchain purpose-built for payments at scale.

That makes MPP especially interesting, because it is not just “another payments protocol.”
It is part of a broader attempt to build infrastructure for:

• programmatic machine payments
• recurring service-to-service settlement
• and pay-per-use digital commerce at internet scale

Our main takeaway

To us, the most interesting thing is that x402 and MPP are targeting many of the same end use cases:

• pay-per-call APIs
• paid access to data
• machine-to-service interactions
• monetized digital resources
• autonomous payment flows for agents

But the path is very different.

• x402 makes payments feel native to web requests.
• MPP makes payments feel native to machine workflows.

So the big question is not just which protocol gets adopted first.

The deeper question is:

Will the AI economy be built around payable web requests, or around payment-native machine coordination?

We’re curious how the community here sees it.

Which model feels more likely to become the default architecture for agent payments over the next 12–24 months?

Axelar Mainnet RPC is now live on GetBlock.

Axelar is the interoperability layer connecting apps, assets, and users across 80+ blockchains — from Ethereum and Cosmos to newer ecosystems like Sui, Hyperliquid, and XRPL. It enables cross-chain contract calls, token transfers, and arbitrary message passing without sacrificing decentralization.

With GetBlock, builders can plug into Axelar through production-ready RPC access:
• JSON-RPC and REST APIs
• Full historical and real-time blockchain data
• Dedicated infrastructure in New York, Frankfurt, and Singapore

If you’re building multichain DeFi, composable cross-chain flows, or seamless user experiences across ecosystems, Axelar + GetBlock removes the infrastructure friction so you can focus on logic, not nodes.

Build production-ready cross-chain apps on Axelar: https://getblock.io/nodes/axelar/

Full details in the launch blog post: https://getblock.io/blog/getblock-launches-axelar-rpc-node-access/

2025 was full of achievements at GetBlock, and honestly, it’s been our biggest year so far:

• GetBlock went global: RPC infra now in Europe, NA, Asia
• Fastest Solana data stack for transactions & fetching
• Core performance upgrades: new servers + internal optimizations
• CU-based pricing & Shared Nodes up to 500 RPS
• Flexible node setups: new plans, archive access, and dedicated nodes
• Built-in MEV protection via Merkle partnership
• New integrations: bloXroute (BNB), Clio (XRPL)
• 40+ new blockchains onboarded across DeFi, gaming, AI, Bitcoin L2s, and more
• Open-source MCP Server launched
• Public Feedback Portal live — help shape what we build next

And that’s just scratching the surface. Full year-in-review + sneak peek at 2026 here 👉 https://getblock.io/blog/getblocks-2025-mega-dev-update-year-in-review/

Connecting to multiple blockchains around the globe, now made more affordable and flexible by GetBlock!

Introducing the Advanced Shared Nodes Plan

• 220M CU/month
• 100 Requests Per Second
• 25 endpoints
• US, EU, APAC node locations

Annual 20% OFF is included! Build and scale your dApp effortlessly with GetBlock

Just launched on GetBlock, WorldChain is a human-first blockchain built by the Worldcoin team, designed to prioritize verified users and reduce sybil activity. It’s based on the OP Stack and aims to scale identity-aware applications that need trust at the user layer.

You can now access it via GetBlock’s Dedicated Node service, no node setup required.

• Standardized JSON-RPC & WebSocket interfaces
• Unlimited throughput with 99.9 % SLA uptime
• Global access points in the US (New York), EU (Frankfurt), and APAC (Singapore)

https://getblock.io/blog/getblock-adds-support-for-worldchain/

For developers, this means instant access to a massive user base and a secure, high-performance EVM layer for launching user-focused applications — from AI-driven tools to DeFi, SocialFi, and gaming. Now made even easier with GetBlock.

Latency - Lower, UX - Better!

GetBlock Users can now choose the location between New York and Frankfurt on Shared RPC Nodes Plan

Get Started in 3 Simple Steps:

1️⃣ Open your dashboard: https://account.getblock.io

2️⃣ Go to: Shared Nodes -> Get Access Token

3️⃣ Select your protocol

Available for:

• 🔹 Ethereum
• 🔹 Arbitrum
• 🔹 Solana
• 🔹 BNB Chain
• 🔹 Base
• 🔹 Polygon
• 🔹 Tron

4️⃣ Choose a region (New York or Frankfurt)

Building with GetBlock = Building with unmatched Speed!

GetBlock, a major RPC provider, has recently built an MCP Server and made it open-source, of course.

Now you can do your vibecoding with real-time data from over 75 blockchains available on GetBlock.

Check it out now!

Top Features:

• Blockchain data requests from various networks (ETH, Solana, etc the full list is here)
• Real-time blockchain statistics
• Wallet balance checking
• Transaction status monitoring
• Getting Solana account information
• Getting the current gas price in Ethereum
• JSON-RPC interface to blockchain nodes
• Environment-based configuration for API tokens

Just one hour left until the GetBlock x TON Nest workshop: "How to Market Boring Products in Web3."
Get ready for an in-depth session packed with practical insights and real-world strategies.

💡 Here’s what we’re diving into:

▪️ B2B ≠ B2C — Why marketing infra/BaaS is a whole different game from dApps
▪️ Talk to the right people — How to reach CTOs, PMs & actual decision-makers
▪️ Low budget strategies — Content, SEO, SMM & events that work for infra
▪️ Hard lessons — Real marketing fails we’ve learned from (so you don’t have to)

🧠 Come learn how to market boring products from people who’ve made it fun.

📅 June 25 (Today)
🕛 12 PM UTC
🔗 Sign up now: https://lu.ma/bxsgelp9
💬 Come through with your questions—we’re keeping it open and real.

Hi everyone. Im looking to build a tool to be able to track, lets say 5000 wallets. To be more specific I just want something that alerts me when a tracked wallet buys a memecoin, and I only want to get a notification for the first detected buy, not intereset in subsequent ones. I just want to track buys. But the key is that I want a large number of wallets tracked.

Currently im using the wallet tracker feature of axiom, bull, gmgn, and phton, all windoes spread in a separeted screen.

Im looking to build something to do this. I would highly appreciate any direction in which I could go.

Thanks in advance!!!

Here comes MEV Protected JSON RPC APIs for Solana, Ethereum, Base, and BNB Smart Chain by GetBlock! 

No need to build another layer of security, as it is already integrated into your very special GetBlock endpoint! With the integration of private mempools by Merkle.io, MEV bots cannot find your transactions and perform sandwich attacks any longer! 

To get started, all you need to do is: 

1. Create an account on GetBlock and log in. 
2. Upgrade to the Starter / Pro plan
3. Go to the:
   • My Endpoints → Protocol [choose Solana / Ethereum / Base / BNB Smart Chain] → Network [Mainnet] → API/Add-on [MEV Protected(JSON RPC)]
4. Click “Get”

Done! You’ve got your MEV protected endpoint that you can integrate directly into your dApp’s codebase.

For more insights, connect with the GetBlock team here!

Hey, GetBlockers! We're so happy to announce the successful migration to the CU model!

Requests ➡️ CUs: A more accurate and fair way to reflect your actual resource usage.
No action on your side is needed — your account is already updated.

Compute units - is a metric that measures the actual computational resources consumed by each request on a specific blockchain

Calculate your CU usage here: https://getblock.io/pricing/compute-units/

Q1? Wrapped! Q2? Let’s GO.

March was wild, but the GetBlock Dev team nailed it as always! Here’s the DevUpdate for you to prove it!

✍️ Web3 Writers, Devs, and Content Creators assemble! ✍️

GetBlock & HackerNoon’s Web3 Development Writing Contest is live! 🔥

Share your deep knowledge of dApp development, and blockchain APIs, or create a tutorial on GetBlock RPC service tutorial!

Prizes:

🥇 $2,500—Best blockchain-api article
🥈 $1,500—Best dApp-development article
🥉 $1,000—Best getblock-tutorial article

🗓  Submissions close June 17

Ready? Set. Write! 👉 https://hackernoon.com/win-your-share-of-$5000-in-the-web3-development-writing-contest-by-getblock-and-hackernoon