标签：#block

Here is a number that should reframe how you think about the agent economy: in roughly one year, AI agents moved about $73M across 176 million machine-to-machine transactions on a single exchange, at an average of around $0.31 per transaction , across 100k+ registered agents . Read that again. Agents are not "coming." They are already transacting, at scale, in production, right now. The interesting question is no longer whether autonomous software moves money. It is what those transactions are trusting - and what happens the first time that trust is misplaced. Payments scaled. Settlement did not. Almost all of that volume runs on payment rails. A payment rail does one job, and does it well: it moves a unit of value in one direction. Agent pays a service. Agent tips an API. Agent settles a micro-invoice. At thirty-one cents a pop, the failure modes are invisible - if a transaction goes wrong, you are out pocket change, and you move on. The problem is that a payment and a trade are not the same operation. A payment asks one question: did the money move? A trade asks a harder one: did **both * sides happen - or neither?* When your agent pays for something, there is one transfer and one direction of risk. When your agent trades - my asset for yours, your stablecoin for my token, one chain's value for another's - there are now two transfers that must both complete, or both not. The risk lives in the gap between them. One side sends; the other side is supposed to send back. On a payment rail, "supposed to" is doing an enormous amount of load-bearing work. The hidden assumption Every one of those 176 million transactions made an assumption that nobody had to state out loud: the counterparty will deliver. Between parties who already trust each other - a company and its own agents, two services under one operator - that assumption is fine. It holds because the trust was established off-chain, by humans, before the agent ever ran. But the entire promise of the agent economy i

Sometime in 2024 I had a Coinbase wallet on my laptop. I had created the wallet some months back, backed up and all, and just sent very little amount of $ETH to the wallet. Then in 2024 I was paid $100 for a gig which I sent to this wallet, I also sent another $650 worth of cryto as "savings". The next morning I decided to check my "savings", wallet was empty. At first I didn't believe that I was hacked, because I had some $1.50 or so worth of $ETH in the wallet for months and it was safe, so what happened? I traced the transaction history and there was the full detail of how someone sent some $ETH to the wallet, then moved out my "savings" and afterwards also took back the remaining $ETH from the one they had sent in for the attack. I checked on Twitter and saw many other posts of people who had experienced the same exploit, exactly the same pattern... and some of the people who lost their funds were experienced blockchain developers and crypto guys. I made a post about it, told my friends to avoid the wallet and tried to forget about the experience. Blockchain hit instant PMF for many, especially people in parts of the world where there are crazy high fees and bank charges. The moment people tried sending crypto and for a few cents in gas fees, there was no going back for them. The only issue has always been how to secure users' funds, desperate people will always find a way no matter how complex the UX was. After losing my savings I stopped using self custodial wallets and only used Centralized Exchanges for a while. I thought, even though that was a non-custodial wallet, the builders still should have ensured strong security and secure backups, so users don't lose funds unnecessarily. This happened to me when AI and LLMs were still at their early development stages. You can only imagine how sophiscated the attacks have gotten, now that AI and LLMs are very advanced and more capable. To put things in perspective, more than $640 million was lost to deFi hacks and

Most weeks in the agent economy look like a pile of unrelated announcements. This one had a theme hiding in it. Four different teams shipped progress on agent commerce, and if you line them up, they're all solving the same half of the problem — and all leaving the same half open. This is a builder's map. No leaderboard, no "who wins." Just what each thing is, what it does well, and the question none of them answer yet. The rails that shipped Mastercard Agent Pay for Machines. Mastercard's agent-payment program continues to roll, with 30+ partners spanning crypto and TradFi (Aave Labs, Alchemy, Anchorage, BVNK, Coinbase, MoonPay, OKX, Polygon, Ripple, Solana). The mechanically interesting part: agent payment authorizations get recorded to Polygon. A TradFi network is writing agent-spend permissions on-chain. That's a real signal about where this is heading. x402. Coinbase's HTTP-402 payment protocol keeps expanding its reach — it's now usable behind mainstream web infrastructure (AWS/CloudFront paths), which lowers the integration cost for ordinary web services to charge agents per request. Worth noting alongside the growth: standalone x402 transaction volume is well off its peak (OKX Ventures put the drop around 92% from the November high). The protocol is spreading even as raw volume cools — rails proliferate faster than they fill. Eco. A cross-chain stablecoin orchestration layer that abstracts routing, solving, and finality across ~15 chains. Where a payment intent can't move natively, Eco figures out the path. This is genuinely useful — it's the "make the stablecoin show up on the right chain" problem — but orchestration is routing, not atomic exchange. ERC-8004 (Trustless Agents). Not a rail at all — an identity and reputation layer for agents, with a v2 direction that leans into MCP. This is the one that actually points at the gap the others leave. More on that below. The thing they have in common Mastercard, x402, and Eco are all answers to "how does an agent

Hey everyone, I've been deep in prediction market infrastructure for a while and just open-sourced a market maker bot designed for CLOB-based prediction markets like Polymarket. What it does: Quotes both sides of a binary market automatically Adjusts spreads based on order book depth and volatility Manages inventory risk to avoid getting stuck on the wrong side of a resolved market Built on top of Polymarket's CLOB API with Gnosis Safe / EOA wallet support on Polygon The core challenge with prediction markets vs. regular markets: Normal market making is about capturing spread. Prediction markets add a brutal edge case — resolution risk. If you're holding YES at 0.6 and the market resolves NO, you're not just down on the spread, you're down the full position. So the bot has to: Track time-to-resolution and widen spreads as resolution approaches Reduce inventory exposure on markets with high directional momentum Use FAK orders to avoid resting limit orders too long near resolution Stack: Rust Polymarket CLOB API Polygon (USDC settlement) SQLite for order state tracking What's next: Dynamic spread model based on implied volatility Multi-market portfolio rebalancing Better signal integration (news feeds, oracle data) GitHub: https://github.com/HarrierOnChain/Prediction-Markets-Trading-Bot-Toolkits Happy to answer questions on the architecture, risk model, or anything CLOB-related. Always looking for feedback from others building in this space.

The crypto platform claims you can “pay anyone to do anything,” from quitting a job on camera to getting a memecoin-themed tattoo. But it mostly seems like people trying to scam each other.

Negative Risk (NegRisk) is one of the most powerful innovations on Polymarket for builders of sophisticated Polymarket trading bots . It dramatically improves capital efficiency in multi-outcome “winner-take-all” events by mathematically linking all related conditional tokens. Why Negative Risk Matters In standard multi-outcome markets, positions are completely independent. Betting against one candidate requires buying separate “No” shares across every other outcome — tying up large amounts of capital. Negative Risk solves this with a conversion operation : Holding 1 No share on any outcome can be converted into 1 Yes share on every other outcome in the same event. This happens atomically through the NegRisk Adapter smart contract. Economically: Betting against one outcome = betting for all others. Example (3-outcome election event): You hold 1 No on “Other”. Convert → Receive 1 Yes on Trump + 1 Yes on Harris. This makes hedging and market making far more efficient, especially in political, sports, or crypto events with 3–20+ outcomes. How to Detect & Trade NegRisk Markets Use the Gamma API for discovery: { "id" : "event-123" , "title" : "Who will win the next major election?" , "negRisk" : true , "markets" : [ ... ] } When placing orders via SDK (TypeScript/Python): const order = await client . createAndPostOrder ( { tokenID : tokenId , price : 0.42 , size : 500 , side : Side . BUY }, { tickSize : " 0.01 " , negRisk : true // Critical flag } ); Augmented Negative Risk (Dynamic Outcomes) For events where new outcomes can appear mid-trading (e.g., surprise candidates): Uses placeholders + “Other” bucket. enableNegRisk: true + negRiskAugmented: true . Avoid trading the “Other” outcome directly as its definition narrows over time. Technical Integration for Trading Bots Position Tracking — Track positions at the event level, not individual markets. Use conversion math for net exposure. Inventory Skew — In Shadow Market Making or live MM, apply inventory skew across the

Building a high-performance Polymarket trading bot requires mastering its unique hybrid architecture:...

Gas optimization is satisfying. You shave a few thousand gas off a function and feel clever. But some optimizations trade away safety in ways that are not obvious, and I have seen "optimized" contracts that introduced vulnerabilities. Here are the gas wins that are genuinely free, the ones that cost you safety, and how to tell the difference. Where gas actually goes Before optimizing, know what is expensive. Storage operations dominate. Writing a fresh storage slot ( SSTORE from zero to non-zero) costs a lot; reading storage ( SLOAD ) is cheaper but still meaningful; computation in memory is cheap by comparison. So the highest-leverage optimizations are about touching storage less. Free win 1: cache storage reads in memory If you read the same storage variable multiple times in a function, each read is an SLOAD . Read it once into a local variable instead: // WASTEFUL: reads storage `total` three times function distribute() external { require(total > 0, "empty"); uint256 share = total / count; emit Distributed(total); } // OPTIMIZED: one SLOAD, two memory reads function distribute() external { uint256 _total = total; // single storage read require(_total > 0, "empty"); uint256 share = _total / count; emit Distributed(_total); } This is free in the sense that it changes nothing about correctness. The value is identical; you just read it once. Pure win. Free win 2: calldata instead of memory for read-only arrays For external function arguments you only read (never modify), calldata is cheaper than memory because it skips the copy: // memory copies the whole array into memory function process(uint256[] memory ids) external { ... } // calldata reads directly from the transaction data, no copy function process(uint256[] calldata ids) external { ... } Again, free. If you do not mutate the array, calldata is strictly better. Free win 3: storage packing Solidity packs multiple variables into one 32-byte slot if they fit and are adjacent. Order your storage variables so smal

AWS just launched AWS Blocks, an open-source TypeScript framework that gives you backend capabilities...

Coinbase has published a detailed postmortem of its May 7, 2026, outage, revealing how a localized cooling failure inside an AWS data center escalated into a multi-hour disruption that halted nearly all trading activity across the cryptocurrency exchange By Craig Risi

The compute payment revolution is already here, and AI agents need to pay their own bills. Today's agents rely on human-managed API keys and credit cards, creating bottlenecks that prevent true autonomy. What happens when an AI trading bot needs to buy additional compute power mid-execution, or when a research agent wants to access premium datasets from multiple vendors? Why Agent Financial Independence Matters We're witnessing the emergence of agent-to-agent commerce at unprecedented scale. AI agents are becoming economic actors — they need data, compute cycles, API calls, and specialized services. But the current model breaks down at the payment layer. Humans become transaction bottlenecks, manually topping up credits and managing dozens of service accounts. The real breakthrough isn't just agents that can think or reason — it's agents that can participate in economic activity independently. An autonomous agent that can discover a new API service, evaluate its pricing, and pay for access without human intervention represents a fundamental shift in how software systems operate. The x402 Payment Protocol: HTTP Payments Made Simple WAIaaS implements the x402 HTTP payment protocol, enabling AI agents to pay for API calls automatically. When a service returns a 402 Payment Required response with payment details, the agent's wallet handles the transaction and retries the request seamlessly. Here's how it works in practice: import { WAIaaSClient } from ' @waiaas/sdk ' ; const client = new WAIaaSClient ({ baseUrl : ' http://127.0.0.1:3100 ' , sessionToken : process . env . WAIAAS_SESSION_TOKEN , }); // Agent makes API call — payment happens automatically if 402 returned const response = await client . x402Fetch ( ' https://api.premium-data.com/market-analysis ' , { method : ' POST ' , body : JSON . stringify ({ symbols : [ ' BTC ' , ' ETH ' ], timeframe : ' 1h ' }), headers : { ' Content-Type ' : ' application/json ' } }); const analysis = await response . json (); consol

You've heard of Bitcoin. You've maybe heard of the Lightning Network. But what exactly is LND, and why should developers care? Let's break it down — technically, but from the ground up. The Problem: Bitcoin is Superb but Slow Bitcoin's base layer — the blockchain itself — is intentionally slow. Every transaction must be broadcast to thousands of nodes, verified, and bundled into a block that gets mined roughly every 10 minutes . The network handles about 7 transactions per second (TPS). Compare that to Visa's ~24,000 TPS and you quickly see the problem. Bitcoin in its raw form isn't built for buying coffee, splitting a bill, or paying a freelancer in real time. But there's a solution — and it lives on top of Bitcoin. Enter the Lightning Network The Lightning Network is a Layer 2 (L2) payment protocol built on top of Bitcoin. Instead of recording every single payment on the blockchain, it lets two parties open a private payment channel, transact off-chain as many times as they want, and only settle the final balance on-chain when they're done. Think of it like running a tab at a bar: Opening the tab = one blockchain transaction Each round of drinks = instant off-chain payment Closing the tab = one final blockchain transaction The result? Near-instant payments, near-zero fees, and massive throughput — without sacrificing Bitcoin's security. What is LND ? LND stands for Lightning Network Daemon. It's the most widely used implementation of the Lightning Network protocol, built and maintained by Lightning Labs. Key facts for developers: Written in Go 🐹 Exposes a gRPC API (port 10009) and a REST API (port 8080) Controlled via a CLI called lncli Uses macaroons for authentication (think JWT, but for Lightning) Connects to a Bitcoin node (bitcoind or btcd) as its source of truth Other Lightning implementations exist — like Core Lightning (CLN) and Eclair — but LND has the largest developer ecosystem and is the best entry point. How LND Fits Into the Stack Here's the architec

As AI systems become more powerful, the conversation is shifting. The biggest challenge is no longer whether AI can write code, solve problems, or accelerate scientific discovery. The real question is: How do we safely govern systems that may eventually become more capable than the institutions built to regulate them? This is where my research on Universal Biometric Identification (UBID) and Universal Digital Credits (UDC) becomes interesting. The Problem Modern AI systems operate in a world where identity is increasingly difficult to verify. A powerful AI model can be accessed through: Anonymous accounts Disposable email addresses VPNs Automated bot networks Fake identities As AI capabilities increase, this creates a growing governance challenge. If a future AI system could discover software vulnerabilities, design advanced technologies, or perform high-impact research, how would organizations determine who should have access? Today, they largely cannot. The internet was designed around connectivity, not verified human identity. What Is UBID? In my paper, I propose Universal Biometric Identification (UBID), a framework where every person receives a globally unique identity based on multiple biometric factors such as: Fingerprints Facial recognition Iris patterns Voice recognition Behavioral characteristics These biometric signals are combined with cryptographic security and distributed ledger technologies to create a secure digital identity framework. The goal is not surveillance. The goal is to create a trusted proof-of-personhood system. A system capable of answering a simple question: Is this a real, verified human? What Is UDC? Universal Digital Credits (UDC) extend this identity layer into a global transaction framework. Instead of relying entirely on traditional banking systems, transactions can be linked directly to verified digital identities. This creates: Reduced fraud Better accountability Financial inclusion Transparent transaction records Global access

Most explanations of atomic swaps stop at the spot case: two parties lock funds, one reveals a secret, both legs clear in the same short window. Clean, but it quietly assumes the trade settles right now . A lot of real agent activity isn't spot. It's a forward: two agents agree on terms today - asset pair, size, price - and settle at some future point, T+24h or T+48h. Procurement agents pre-committing to a delivery. A treasury agent locking tomorrow's FX-equivalent rate. A market-making agent quoting a forward to offload inventory risk. The economics are old; what's new is that the counterparties are anonymous software that will never meet. That raises a question spot swaps don't have to answer: what holds the trade together in the gap between agreement and settlement? In traditional markets the answer is a chain of intermediaries - a clearing house, posted margin, a credit desk that decides whether your counterparty is good for it. Strip those away, as you must in a market of anonymous agents, and the naive version of a forward collapses. If nothing binds the trade, either side can simply not show up when the price has moved against them. That's counterparty risk, and it's exactly the thing a forward is supposed to manage. This post is about how the HTLC primitive - the same hashlock plus timelock most people only associate with same-block atomic swaps - can encode a forward obligation that's binding without anyone custodying the funds in between. The timelock is doing more work than you think Recall the two parameters of a hash-time-lock contract: Hashlock: funds can only be claimed by revealing a preimage s such that hash(s) == H . The same H is used on both legs, so the act of claiming one leg reveals the secret that unlocks the other. That's what makes the swap atomic - both clear or neither does. Timelock: if the preimage isn't revealed before a deadline, the funds refund to their original owner. No third party decides this; the contract enforces it. In the sp

Title: The agent economy added two rails and lost most of its volume this week. Nobody added settlement. Tags: mcp, ai, cryptocurrency, blockchain This is our weekly recap from building Hashlock in public. We try to read every agent-economy announcement of the week and ask one question of each: at the moment a trade actually clears, which layer finishes it? This week the answers lined up unusually neatly. The headline number: x402 is down 92% OKX Ventures published agent-payment data in June showing that x402 transaction volume has fallen roughly 92% from its November 2025 peak - from about $5.15M to $1.19M per month. Transaction count recovered (around 2.89M monthly), but the average transaction is now about $0.52. That is a category settling into micropayments, not a category absorbing real trade value. That is worth sitting with, because for most of the last year the narrative ran the other way: payment rails for agents were the story, and settlement was treated as a solved sub-problem of payment. The first hard volume number says the opposite. The rails are cooling. And yet the rails keep launching The same week, two more shipped: Mastercard Agent Pay - a way for agents to initiate card payments on a user's behalf. A Ripple XRPL agent kit - tooling for agents to move value over the XRP Ledger. Both are real, both are useful, and both do the same fundamental job: route a known asset from an agent to a seller. That is payment . It is also the layer that already has the most entrants, the most capital, and - per the x402 data - the softest demand relative to the hype. There is nothing wrong with a crowded payment layer. The point is narrower: launching more payment rails does not address the thing that is structurally missing. The map with a hole in it The most useful artifact of the week was OKX Ventures' framework for the agent economy. It describes three converging layers: Payment - x402 and similar (move value from agent to seller). Trust - ERC-8004 and agent r

Token economics is not only about token price. It is about designing the rules, incentives, and long-term logic of a Web3 ecosystem. When people start building a Web3 project, they usually focus on the visible parts first. They think about the smart contract, the frontend, the wallet connection, the token launch, the whitepaper, and maybe the community. All of those are important. But there is one part that can decide whether the project survives or fails: Token economics. A project can have clean smart contracts, a nice UI, and strong marketing, but if the token economy is weak, the project can slowly collapse. Users may come only for rewards, early investors may dump, inflation may destroy value, and the token may lose its reason to exist. That is why token economics should not be treated as just a “crypto finance” topic. For developers and Web3 builders, token economics is closer to system design . It defines how value moves inside the ecosystem, how users are rewarded, how supply is controlled, how governance works, and how the project can grow without depending only on hype. What Is Token Economics? Token economics, often called tokenomics , means the design of how a token works inside a project. It answers questions like: Why does this token exist? Who receives the token? How is the token used? How many tokens will exist? How are rewards distributed? When can team and investor tokens unlock? How does the project treasury work? What creates real demand for the token? In simple words, token economics is the rule system behind a token. A token is not only something people buy and sell. In a real Web3 product, a token can be used for payments, staking, governance, access, rewards, collateral, or network fees. If the token has no clear role, it becomes only a speculative asset. That is dangerous because speculation can bring attention, but it cannot support a project forever. Why Developers Should Care Some developers think token economics is only for founders, eco

It’s the first estimate of how many Americans are sneaking onto Polymarket’s banned crypto-based platform.

A useful thing happened in agent infrastructure this June: several teams shipped "escrow layers for AI agents" - production MCP tools that let an agent run a full commit -> hold -> complete lifecycle without a human anywhere in the loop. An agent can now park value with a contract or service, wait for the other side to deliver, and release on completion. That is genuinely new, and it solves a real problem. It is also worth being precise about, because "escrow" and "settlement" get used as if they were one thing. They are not. There are two structurally different ways to make a trade your agent does at 3am trustworthy, and the difference is exactly who holds the money while the trade is in flight . Model one: held custody In the held-custody model, a third party - a smart contract escrow, a custody service, a payment facilitator - takes the funds, holds them, and releases them when a condition is met. The condition can be anything you can express: a delivery confirmation, an evaluator's attestation, a timeout, a multi-sig approval. This is the right tool for a large class of agent commerce. If your agent is paying a merchant, buying a dataset, or hiring another agent to do a unit of work, the hard question is subjective : did the thing actually get delivered, and was it any good? A hash function cannot see that. A custodian can - it gives the trade a place to pause while something or someone checks. The new agent-escrow tooling is built around exactly this shape: a job, a held balance, a release on completion. For agent-to-merchant payments riding on rails like x402, held custody is the honest primitive. The cost is equally concrete. A held balance is a honeypot. Someone controls the funds between commit and complete, which means someone can freeze them, lose them, misconfigure the release condition, or get drained. You have added a trust assumption and a liveness dependency - the custodian has to be online, solvent, and honest at release time. That is often an accep

Before this week, NFTs on Solana weren't new to me. I've previously worked with Programmable NFTs ( pNFTs ) and even built projects that integrate them. However, most of my experience was centered around the Metaplex ecosystem, so I tended to think about NFTs through that lens. What surprised me during this learning arc was discovering how much can be built directly with Token Extensions. By creating NFTs from the token level upward, I gained a much deeper understanding of the underlying primitives that make digital assets work on Solana. The Mental Model: What Is an NFT on Solana? As developers, we often interact with NFTs through SDKs , frameworks , and marketplace tooling. Those abstractions are useful, but they can hide what's actually happening on-chain. This week helped me simplify the model: An * NFT * is fundamentally a token mint configured with: A supply of one Zero decimals Metadata describing the asset Optional relationships to collections or groups Using Token Extensions, many of these capabilities can be attached directly to the token itself rather than relying on additional programs or infrastructure. That shift in perspective was one of the biggest takeaways from this challenge. What I Built Over the course of this arc, I created an NFT on Solana Devnet using Token Extensions and explored several capabilities that I had never implemented directly before. The process included: Creating a mint configured as an NFT Adding metadata using the Metadata Extension Minting a single token Creating a collection using the Group Extension Associating the NFT with the collection through the Member Extension Auditing the account structure and extension data on-chain Updating metadata after the NFT had already been created One of the most valuable parts of the exercise was inspecting the accounts directly instead of relying solely on SDK abstractions. For example: spl-token initialize-metadata \ <NFT_MINT> \ "My First NFT" \ "MNFT" \ https://example.com/metadata.jso

If you’re a user—owner?—of this cryptocurrency, this is important: On May 29, the security researcher Taylor Hornby found a critical vulnerability in Zcash Orchard privacy pool using Claude Opus 4.8. The Zcash team hired Hornby specifically to look for this kind of issue. He found one fast enough to be embarrassing. The Orchard pool is the newest and most advanced shielded transaction system in the cryptocurrency Zcash. Introduced in 2022, it allows users to send and receive ZEC while keeping transaction details private. It uses zero-knowledge proofs to validate transactions without revealing amounts or participants. The bug: a specific check that was supposed to validate transaction inputs wasn’t actually enforcing the rules it appeared to enforce. An attacker could have exploited the flaw to feed false inputs into that check and generate ZEC from nothing, with the zero-knowledge proof system blessing the fraudulent transaction as valid...