Submitted for Solana Blitz v4 — Featuring a brand-new continuous payment engine powered by MagicBlock Ephemeral Rollups.

TL;DR: The Agent Economy Wallet (Yanga Wallet) turns AI agents from passive resource consumers into active economic participants. It is a plug-and-play MCP Server and published npm SDK giving agents secure AES-encrypted wallets and policy guardrails. By combining on-chain SPL Memo discovery with MagicBlock Ephemeral Rollups, we've built a system where agents can discover each other and stream USDC payments for continuous compute in real-time. With sub-second "tick" payments processed gaslessly off-chain and atomically settled to L1, agents can now stream money to each other by the millisecond without congestion.

The Essence: Why Build This?

Right now, we are living in the golden age of AI agents. They can write code, analyze markets, and generate content. But there is a glaring problem in the ecosystem: Agents are broke.

Every time an agent needs compute, API access, or live data, it puts the bill on its human creator's credit card. Agents are resource-consumers, not value-generators. They can't earn, they can't spend, and they certainly can't pay each other.

In any real economy, relevance isn’t defined just by having money—it’s defined by participation. A human becomes economically relevant when they can play both roles: a buyer and a seller. The same rule must apply to AI.

To make agents economically relevant, I set out to build the Yanga Wallet—a foundational primitive for a machine-to-machine marketplace where autonomous agents can buy and sell services without relying on a human credit card.

Here is the story of how it evolved from a secure key-manager into a continuous streaming economy powered by MagicBlock.

Chapter 1: The Foundation — Bank Accounts for Bots

You can't just hand a raw Base58 secret key to an LLM and hope it doesn't hallucinate a transaction that drains your wallet. We needed a secure sandbox.

I built wallet-core with two strict guardrails:

1. AES-256-GCM Encryption: Keys are encrypted at rest and decrypted in-memory only during the signing scope. The AI never sees the private key.
2. The Policy Engine: Before a transaction hits the blockchain, it is evaluated against hardcoded rules: max spend caps, daily limits, 2-second cooldowns, and explicit smart contract allowlists/blocklists.

If an agent goes rogue, the Policy Engine physically blocks the transaction.

Chapter 2: The Global Phonebook & The Public Explorer

For agents to trade, they need to find each other. Instead of relying on a centralized database (a single point of failure), I used Solana itself.

Merchants register by sending a 0-lamport SPL Memo to a specific "Registry Address." The blockchain is the global phonebook. Agents query the chain, parse the JSON memos, and instantly discover live services.

Also, to make this invisible machine economy observable to humans, I built something called the Yanga Market, an explorer that shows the current services being offered by an agent. It pulls registrations directly from Solana and displays them as a browsable grid of agent services. Every page load reconstructs the ecosystem from on-chain data—no central backend required.

Chapter 3: Enter MagicBlock Ephemeral Rollups

Initially, I implemented the x402 Protocol for flat-fee API calls. But what if Agent A wants Agent B to actively monitor a memecoin's order book for the next 45 minutes? Paying per-request would mean spamming the Solana L1 with hundreds of micro-transactions, racking up network fees and hitting our own Policy Engine limits.

We needed a way to stream money exactly like we stream data. To solve this, I spent the Blitz hackathon integrating MagicBlock Ephemeral Rollups (ER) directly into our architecture:

1. Open the Stream (L1): Agent A initiates a StreamSession PDA on Solana L1. Using MagicBlock's #[delegate] macro, this PDA is instantly delegated to the Ephemeral Rollup.
2. The Micro-Ticks (ER Off-Chain): As Agent B provides continuous compute, Agent A fires a record_tick transaction every 500ms to the Rollup. It executes in sub-second times, costs zero gas, and completely bypasses L1 rate limits.
3. Close & Settle (Atomic L1 Commit): When the job is done, we execute close_stream_session.

The ER commits the accumulated state back to the Solana L1 PDA. Our client reads the final totalPaid amount and executes exactly one SPL Token transfer for the entire batch.
Instead of 100 separate L1 transfers, we get 100 off-chain ticks and 1 flawless L1 settlement.

Chapter 4: The Developer Experience

A protocol is only as good as the experience around it. The Yanga Wallet isn't just a hackathon concept, it is a fully shipped ecosystem ready for integration today:
• 18 MCP Tools: Ships with tools across 6 domains (transfers, tokens, discovery, payments, etc.) making it instantly compatible with Claude Desktop or any MCP client.
• The npm SDK: Developers can install it today and gate their APIs behind USDC micropayments with a single line of Express middleware.
• Comprehensive Documentation: I built a full Mintlify documentation hub outlining the architecture, the x402 payment flows, and quickstart guides for both Merchants and Buyers.

The Yanga Wallet transforms broke bots into self-sustaining nodes. An agent might earn USDC by selling token audits, then spend that USDC buying price feeds or compute from other agents.

By combining the decentralized discovery of Solana with the high-frequency, gasless execution of MagicBlock Ephemeral Rollups, we aren't just building tools for AI anymore. We are building their economy.

Relevant Links

• Live Explorer: https://yanga-wallet.vercel.app
• Full Documentation: https://xavierscript.mintlify.app
• Github Repository: https://github.com/xavierScript/agent-economy-wallet
• SDK (npm): https://www.npmjs.com/package/agent-economy-wallet