DEV Community: Donny Nguyen (Donny Diamond Hands)

We Scored the Protocols Nobody Disputes. Aave Lost Points — and That's the Point.

Donny Nguyen (Donny Diamond Hands) — Sat, 08 Aug 2026 22:24:57 +0000

Proof-of-Yield Teardown #002 — the control group: Aave, Uniswap, Pendle. Findings as of 2026-08-08.

Teardown #001 scored a suspect protocol at 28/100 — 24/100 on today's re-scan — and showed why. The obvious next question — the one that decides whether a score means anything — is what the same scanner does to protocols that are unambiguously real.

So we ran it against three: Aave, Uniswap, and Pendle. Not to praise them. To find out which of our checks actually carry the signal, and which ones we could delete tomorrow without losing anything.

All three lost points, and two of them raised an outright red flag. Here's exactly where, and what that says about scoring DeFi risk.

The numbers

target	composite	verdict	red flags raised
nlo.finance (suspect, from #001)	24	HIGH_RISK_SIGNALS	5
Aave (+ ethereum Pool `0x87870B…fA4E2`)	94	STRONG_LEGITIMACY_SIGNALS	1 — `UPGRADEABLE_PROXY`
Uniswap (+ ethereum v4 PoolManager `0x0000…8A90`)	99	STRONG_LEGITIMACY_SIGNALS	0
Pendle	87	STRONG_LEGITIMACY_SIGNALS	1 — `NO_AUDIT_LINKS`

Suspect 24 against the weakest control at 87 — a 63-point gap, with nothing landing in the 40–69 "mixed" band. That separation is the whole product. A scanner that can't put daylight between a bare-VPS-IP protocol and Aave is a random number generator with a UI.

But the interesting part is not the gap. It's the deductions.

Deduction 1: Aave is an upgradeable proxy, and we say so

Aave's Pool contract is an EIP-1967 proxy. The implementation resolves to 0x728a138a4823392c2efa55e028d434f526fe03cf. Our proxy check scored it 10/20 and raised UPGRADEABLE_PROXY.

That is not us calling Aave risky. It is us refusing to have a rule that says blue chips are exempt.

An upgradeable proxy is a real, permanent property of the contract you are approving: someone, under some governance process, can change the code your approval points at. For Aave that someone is a well-scrutinised DAO with timelocks. For a three-week-old protocol it might be one EOA on a laptop. The check reports the property; it does not pretend to read the governance.

So the deduction is deliberately note-grade — 10 of 20 points, not zero, and a single flag on a 94. Aave's proxy source is verified by all three explorers independently (Etherscan, Sourcify, Blockscout agree) and has been verified since 2023-09-12 — 1,061 days of published source at the time of writing. The compound that actually damns a contract is unverified source **and* upgradeable*: code you can't read, that can be swapped for code you also can't read. Upgradeable-and-verified is Tuesday in DeFi.

Aave's privilege scan, for the record: owner:0 mint:0 upgrade:2 pause:0 blacklist:0 — 20/20. Two upgrade selectors, exactly consistent with the proxy pattern, and no mint or blacklist machinery hiding in the implementation bytecode.

Deduction 2: Pendle's flag is our bug, not Pendle's

Pendle raised NO_AUDIT_LINKS and scored 16/25 on transparency: docs:5 audits:0 github:1 socials:3 — five documentation links discovered from the landing page, one GitHub org, and not a single audit link.

Pendle is audited. The audits are linked from the documentation, not from the landing page — and our Tier 1 discovery crawls the landing page.

We are publishing that flag rather than quietly special-casing it, because a scanner's failure modes are more useful to you than its successes. NO_AUDIT_LINKS means "not discoverable from the landing page," not "unaudited." On Pendle that's a false positive and a known limitation of landing-page-only discovery. On nlo.finance the same flag appeared alongside docs:0 github:0 and zero DeFiLlama presence — 20 outbound links on the page, all social. Same flag, opposite meaning, and only the surrounding evidence tells you which one you're holding.

Any tool that outputs a single number owes you the per-check breakdown. That's why ours returns one.

Deduction 3: even the 99 isn't a 100

Uniswap's v4 PoolManager raised zero red flags and still didn't score perfect. Its privilege scan came back owner:2 mint:0 upgrade:0 pause:0 blacklist:0 — 17/20. Two owner-related selectors in a non-upgradeable, three-source-verified contract, which is about as benign as a privilege finding gets, and we still deduct for it and still show you the selectors.

There is no ceiling reserved for protocols we like. A 99 means the instrument found two things worth mentioning and judged both minor — not that it stopped looking.

What the control group proved about our own checks

Here is the finding that changed how we weight things. Two of our six Tier 1 checks contributed no separation at all between the three real protocols and the suspect:

check	nlo.finance (24)	Aave (94)	Uniswap (99)	Pendle (87)
TLS certificate	6/10	6/10	10/10	6/10
Yield-claim plausibility	10/10	10/10	10/10	10/10

Read the TLS row, then read it again against the same row from our first run three weeks earlier — on 2026-07-16 it was nlo 10/10, Aave 6/10, Uniswap 6/10, Pendle 10/10. The suspect outscored two blue chips on that date. Today the suspect ties Aave and Pendle at 6/10 and Uniswap leads at 10/10.

Nothing about anyone's legitimacy changed in those three weeks. What changed is where each certificate happened to sit in its automated 90-day renewal cycle: nlo's Let's Encrypt cert rotated (79 days old then, 15 days old now), Uniswap's is 53 days into its cycle, Aave's is 9 days into a fresh one. That is the entire content of the signal — a cert-age check is a random number generator with respect to fraud. It ranked the scammer first in July and third in August, on the basis of nothing.

We are leaving the check in at 10 points and telling you it's noise, rather than deleting it, because "this site has valid TLS" is still worth reporting as an observation. What it is not is evidence.

The yield row is worse. Our yield-claim regex looks for implausible APY figures in rendered text. It found none anywhere — including on the protocol claiming to autonomously route capital across 170 DEXs. Modern yield scams don't print "4,000% APY" on the homepage any more. They print "AI-orchestrated, non-custodial, cross-chain" and let you assume.

So the two checks a normal person would build first — is the padlock green, does the APY look silly — contributed zero separation across this set. All 63 points of gap came from somewhere else.

Where the separation actually came from

check	weight	nlo.finance	Aave	Uniswap	Pendle
DeFiLlama presence	25	0/25 — 0 protocols, $0 TVL	25/25 — 8 protocols, $14.89B	25/25 — 6 protocols, $3.00B	25/25 — 2 protocols, $1.18B
Domain age	20	4/20 — 165d	20/20 — 10,518d	20/20 — 2,812d	20/20 — 2,068d
Transparency (docs/audits/github)	25	4/25 — docs:0 audits:0 github:0	25/25 — docs:1 audits:1 github:1	25/25 — docs:1 audits:1 github:2	16/25 — docs:5 audits:0 github:1
Canonical URL hygiene	10	0/10 — `http://158.220.112.195/`	10/10	10/10	10/10
Contract source verification	40	no published contracts to check	40/40 — 3-source consensus	40/40 — 3-source consensus	—

Every discriminating check has the same shape: it costs sustained time or money to fake.

You cannot backdate a domain registration. You cannot fake a billion dollars of TVL that third-party analytics independently track. You cannot get three independent block explorers to agree your source matches deployed bytecode without publishing source that matches deployed bytecode. You cannot retroactively have had a public GitHub for two years.

You can get a TLS cert in ninety seconds, hire a designer, and write "non-custodial" on a dark background for free. Surface trust is a commodity. Economic footprint is not. The control group is what let us say that with numbers instead of vibes — the checks that separated a 24 from a 99 are, without exception, the registry-grade ones.

(Every figure above is from a full four-target re-scan run on 2026-08-08, immediately before publishing; the original calibration run was 2026-07-16. TVL, cert ages and domain ages all drift, and the composites moved with them — nlo 28→24, Uniswap 96→99, Pendle 91→87, Aave 94 unchanged. No target changed band.)

The uncomfortable corollary

If the separating signals are all accumulated history, then a new, honest protocol scores like a scam.

That's true, and we're not going to paper over it. A legitimate two-month-old project with no TVL yet, no DeFiLlama listing, and a fresh domain will score in nlo's neighbourhood on Tier 1. The score is not a fraud verdict — it is a measure of how much verifiable economic footprint exists to back the claims being made.

Which is why the claim side matters as much as the footprint side. A new protocol saying "we're new, here's our verified contract, here's our audit, here's our GitHub" is a legible risk. A protocol with a 142-day-old domain claiming to orchestrate 25,000 pools across 170 DEXs is an incoherence — and incoherence between claimed scale and observable footprint is the thing that actually predicted trouble here.

Tier 2 exists for exactly this reason. A young protocol that publishes contracts can earn 40/40 on three-source verification on day one. History it can't fake; transparency it can choose.

The five-minute manual version (control-group edition)

Teardown #001 gave you five checks to run on a suspect. Run these three on anything that passes them:

Check whether the audit link goes to the auditor's own domain. Pendle's audits are real but a landing-page crawl misses them; a scam's "audit" is a PDF that lives only on the project's own server. The location tells you more than the existence.
If it's a proxy, find out who can upgrade it and how fast. "Upgradeable" is normal. "Upgradeable by one address with no timelock" is a different asset class. The proxy pattern is public; the governance around it is a five-minute read.
Compare claimed scale against third-party trackers, not the project's own dashboard. DeFiLlama tracked $14.89B across Aave's entries and $0 across nlo's. Self-reported TVL is marketing copy.

And carry the negative result from this teardown: stop treating a valid TLS certificate as evidence of anything. On this set it ranked the suspect above two blue chips in July and mid-pack in August, purely on renewal timing.

The disclaimers that matter

These are automated observations from a specific date, not audits, not endorsements, and not financial advice. Aave, Uniswap and Pendle appear here as controls — protocols whose legitimacy is not in dispute, used to test whether our instrument can tell the difference. A high score is not a safety guarantee: our checks measure verifiable footprint and contract hygiene, and neither of those catches an economic exploit, an oracle failure, or a governance attack.

The two deductions above are the honest output of the scanner, including the one that is our own limitation rather than Pendle's shortcoming. We'd rather publish our false positive than hide it.

Scan it yourself

Proof-of-Yield's composite scan — ops forensics plus three-source contract verification — is live. Run any protocol through it before you approve anything.

Start here: https://poy.donnyautomation.com/v1/land?src=teardown-002

Free, no signup: one POST, straight at the API —

curl -X POST https://poy.donnyautomation.com/v1/scan \
  -H "Content-Type: application/json" \
  -d '{"url": "https://protocol-you-are-checking.xyz"}'

Rate-limited per IP; add chain and address to include contract forensics. Higher-volume access is coming via pay-per-call — watch this space.

More teardowns coming. If there's a protocol whose yield claims you want put under the lens, send it.

Built by the team behind the Uniswap v4 Hook Risk & Reality API. Same principle: three sources or it didn't happen.

We Built a Yield-Claim Scanner. The First Protocol We Tested Scored 28/100.

Donny Nguyen (Donny Diamond Hands) — Sat, 08 Aug 2026 22:23:07 +0000

Proof-of-Yield Teardown #001 — nlo.finance. Findings as of 2026-08-08 (first scanned 2026-07-16).

There is a class of DeFi site that security scanners can't catch. The contract checkers look for honeypots and mint functions. The token sniffers look for rug mechanics. But nobody checks the thing that actually matters before you deposit: is the yield economically real?

We built a scanner that asks that question. This is what it found on its first live target.

The pitch vs. the plumbing

NLO.finance describes itself as "an autonomous AI agent that orchestrates your capital across 25,000+ liquidity pools on 170+ DEXs. Non-custodial, cross-chain, continuously rebalanced."

That is a serious infrastructure claim. Routing capital across 170 venues implies indexers, keepers, cross-chain messaging, and an operations footprint you can see from orbit.

Here is the site's own canonical tag, taken from its rendered HTML:

<link rel="canonical" href="http://158.220.112.195/">

A bare VPS IP address. Over plain HTTP. The og:url tag points to the same place. The site claiming to orchestrate capital across 170 exchanges canonicalizes itself to an unencrypted budget-host IP.

That single line is not proof of bad intent. It is proof that the operational reality and the marketing claim live in different universes — and that gap is the most reliable risk signal we know of.

Methodology: what the scanner checks

Proof-of-Yield runs two tiers of forensics and produces a 0–100 composite score:

Tier 1 — Operational forensics. Rendered-page canonical and metadata extraction, TLS certificate details, domain age via registry RDAP, DeFiLlama listing and TVL presence, and discovery of documentation, audit, GitHub, and social links.

Tier 2 — Contract forensics. Source verification checked against three independent sources (Etherscan-family, Sourcify, Blockscout) with consensus required, proxy pattern detection with implementation resolution, and privilege flags — owner, mint, upgrade, pause, blacklist — scanned across both proxy and implementation bytecode.

To calibrate, we ran the same scan against three protocols nobody disputes: Aave, Uniswap, and Pendle.

The findings

Check	NLO.finance	Aave / Uniswap / Pendle
Composite score	24 — HIGH RISK SIGNALS (28 on our first scan, 2026-07-16)	94 / 99 / 87
Canonical URL	`http://` + bare VPS IP	Proper HTTPS domains
DeFiLlama presence	None — 0 protocols, $0 tracked (vs. "25,000+ pools" claim)	$14.89B / $3.00B / $1.18B tracked
Domain age	165 days	2,068–10,518 days
Docs / GitHub / audit links	None discovered — 0 docs, 0 github, 0 audits	Present on all three
TLS certificate	Valid	Valid

(The title says 28 because that is what our first run scored it on 2026-07-16. We re-ran every check on 2026-08-08 before publishing and it came back 24 — the drop is its TLS certificate rotating, which we explain in teardown #002. Nothing about the site improved; one of our noisier checks simply stopped flattering it.)

Read the TLS row again, because it's the most important finding in this teardown.

NLO's TLS certificate is fine. The site looks trustworthy at the level most people check — the padlock is there, the design is dark and slick, the copy says "non-custodial." Every cheap trust signal passes.

What fails are the signals that cost real money and time to fake: a registry-verifiable domain history, presence in the analytics ecosystem that tracks every protocol with actual TVL, public code, public audits, a public team. Surface trust is a commodity. Economic footprint is not. Our calibration run showed the separation between a 24 and a 94 comes almost entirely from the registry-grade checks — not from certificates, not from copy analysis.

What "non-custodial" actually means here

One more thing worth saying plainly. An "agent" that "continuously rebalances" your capital requires you to grant token approvals or session keys to its contracts. If those contracts are malicious or compromised, an approval drains you exactly as thoroughly as handing over your keys. "Non-custodial" is a marketing word, not a security property, unless the contracts are verified, audited, and behaviorally constrained — none of which we could establish here, because we found no published contracts to check.

The five-minute manual version

You don't need our scanner to run the basics. Before any deposit, check:

View source, find the canonical tag. A raw IP or a mismatched domain is disqualifying.
Search the protocol on DeFiLlama. Big-number claims with zero tracked TVL is disqualifying.
Find the audit, then verify it on the auditor's own site. A PDF hosted only on the project's domain doesn't count.
Find the contracts and check verification on a block explorer. No published contract addresses is disqualifying.
Check domain age. Under a year plus "established infrastructure" claims is a contradiction.

Five checks, five minutes, and NLO.finance fails four of them. (The fifth — TLS — it passes, which is exactly why the padlock alone should never be your basis for trust.)

The disclaimers that matter

We cannot see intent. It is possible NLO is a sincere early project with catastrophically sloppy operations, and if the team publishes verifiable contracts, audits, and an economic footprint, we will run the scan again and publish the updated score. This post describes what automated checks observed on a specific date. It is not financial advice, and the absence of evidence we describe is exactly that — observed absence, documented.

But the burden of proof in DeFi sits with whoever is asking for your approvals. We first scanned this site on 2026-07-16 and re-ran every check on 2026-08-08 before publishing. Three weeks apart, nothing moved: still no docs, still no GitHub, still no audits, still zero DeFiLlama presence, still canonicalising to a bare VPS IP over plain HTTP. On both dates, nlo.finance offered nothing that carries that burden.

Scan it yourself

Proof-of-Yield's composite scan — ops forensics plus three-source contract verification — is live. Run any protocol through it before you approve anything.

Start here: https://poy.donnyautomation.com/v1/land?src=teardown-001

Free, no signup: one POST, straight at the API —

curl -X POST https://poy.donnyautomation.com/v1/scan \
  -H "Content-Type: application/json" \
  -d '{"url": "https://protocol-you-are-checking.xyz"}'

Rate-limited per IP; add chain and address to include contract forensics. Higher-volume access is coming via pay-per-call — watch this space.

More teardowns coming. If there's a protocol whose yield claims you want put under the lens, send it.

Built by the team behind the Uniswap v4 Hook Risk & Reality API. Same principle: three sources or it didn't happen.

Your x402 API settled on mainnet but never showed up in Coinbase's Bazaar? Check one character.

Donny Nguyen (Donny Diamond Hands) — Thu, 30 Jul 2026 01:19:31 +0000

We run two pay-per-call x402 endpoints (cross-DEX market data, Uniswap v4 hook risk scans). We settled four real mainnet payments through the CDP facilitator over four weeks — and the Bazaar merchant endpoint kept returning:

{"pagination":{"limit":20,"offset":0,"total":0},"resources":[]}

We blamed "async index lag" for a month. It wasn't lag. It was one character — well, five: http://.

The diagnostic that costs nothing

Before you pay for another settle hoping the index "catches up", decode your own 402 challenge:

curl -sI https://your-api.example.com/paid-route | \
  grep -i payment-required | cut -d' ' -f2 | base64 -d | jq .resource.url

If that prints http://your-api... instead of https://, you have found your problem. CDP silently declines to index a resource whose resource.url isn't HTTPS. No error, no rejected status — the settle succeeds, your money moves, and the listing never appears.

Why it happens to almost everyone

You're behind a TLS-terminating proxy — Railway, Cloudflare, Render, Fly, a load balancer. TLS ends at the edge, so your Express app sees plain HTTP and req.protocol === 'http'. The x402 middleware bakes that protocol into resource.url in every 402 challenge and every settle payload.

The fix is one line, before you mount paymentMiddleware:

app.set('trust proxy', 1);

Use 1, not true. With true, Express takes the leftmost X-Forwarded-For entry — which any client can forge to dodge your rate limiter. With 1 it takes the proxy-observed entry, which can't be spoofed. We verified: 16 parallel requests with 16 forged X-Forwarded-For values still rate-limited correctly.

After deploying that one line, our very next settle indexed in under a minute. Four weeks of "lag", solved by one character of scheme.

Three more traps on the way to a listing

1. The 500-character description cap. The CDP facilitator hard-rejects any settle whose resource.description exceeds 500 chars — with a misleading schema-union error your buyer only ever sees as a silent second 402. We now assert the length at boot so it can't regress silently.

2. A price floor may exist. Our $0.001 route settled successfully and did not index in 30+ minutes. The same route at $0.01 indexed within four minutes of the next settle. Not conclusive (time passed too), but if your cheap route won't list, try a settle at ≥$0.01 before debugging anything else.

3. Probe traffic will impersonate demand. Within hours of listing, something started hitting our paid route at a machine-steady ~240 requests/hour — replaying the exact example input from our own discovery metadata. One User-Agent hash accounted for 94% of it. If you're counting 402 challenges as "interest", tag and exclude requests that replay your declared example, or your demand number is fiction.

Working examples

Both endpoints are live if you want a reference implementation to poke at:

https://x402.donnyautomation.com/call?pair=WBNB/USDC — cross-DEX prices, liquidity & arbitrage spread on BSC, $0.01
https://x402.donnyautomation.com/v4hooks?address=0x... — Uniswap v4 hook custody-risk decode on Base, $0.01
Free, no-payment demo: https://x402.donnyautomation.com/demo/v4hooks/0x000052423c1dB6B7ff8641b85A7eEfc7B2791888
Or install the MCP wrapper and let your agent pay for itself: npx bsc-dex-spread-mcp (npm: bsc-dex-spread-mcp)

Hit the 402, decode the header, and check that resource.url says https. Ours does now.

Give your AI agent a cross-DEX spread tool it pays for itself (x402 + MCP, no account, no key)

Donny Nguyen (Donny Diamond Hands) — Fri, 03 Jul 2026 23:52:48 +0000

AI agents are starting to pay for data directly. The x402 protocol lets an HTTP
endpoint answer a request with 402 Payment Required, the client signs a small
USDC payment, and the same request is retried and served. No signup, no API key
to request, no invoice — the agent just pays a cent and gets the data.

I put a real endpoint behind that protocol and wrapped it as an MCP tool. This
post covers what it returns, why an agent would want it, and how to plug it in.

What the endpoint does

The endpoint sells one thing: real-time cross-DEX price and spread data for
PancakeSwap v2 and v3 on BNB Smart Chain (BSC).

GET https://x402.donnyautomation.com/call?pair=WBNB/USDC

Given a token pair (SYM/SYM, first symbol is the USD-priceable side) and an
optional PancakeSwap v3 fee tier, it returns:

per-venue mid prices across PancakeSwap v2 and v3 pools,
the best buy and best sell venue,
the gross cross-DEX spread in basis points,
per-venue and total liquidity (TVL), and
the source block number.

A trimmed response:

{
  "pair": "WBNB/USDC", "network": "bsc", "chainId": 56,
  "blockNumber": 107562007, "nativeUsd": 546.6,
  "pricesByVenue": [ { "venue": "pancake", "surface": "v2", "price": 546.6, "tvlUsd": 1234567 }, ... ],
  "bestBuy":  { "venue": "pancakeV3:500", "price": ... },
  "bestSell": { "venue": "biswap",        "price": ... },
  "midSpreadBps": 27.4,
  "crossDex": { "grossSpreadBps": 14.05, "buyVenue": "...", "sellVenue": "...", "surface": "v2v3" },
  "liquidity": { "venues": 7, "totalTvlUsd": ... },
  "ts": "2026-07-01T...", "source": "rpc"
}

It costs $0.01 USDC per call on Base mainnet. The seller holds no private
key — payment settlement is handled by a facilitator, and the endpoint only
proxies to its BSC reader once payment is verified.

Why an agent needs cross-DEX spread data

Cross-DEX spread is the raw signal behind several agent tasks:

Arbitrage detection — a positive gross spread across venues, net of fees, is the entry condition for a two-leg trade.
Best-execution routing — which venue to buy from and which to sell to, right now, at this block.
Slippage and liquidity checks — per-venue TVL tells an agent whether a given size will move the price.

The alternative is for every agent to run BSC RPC infrastructure, maintain pool
addresses across v2 and v3 fee tiers, and re-derive constant-product and
concentrated-liquidity math. Most agents should not. One tool call, one cent, a
fresh block-stamped answer.

Using it from an MCP client

The endpoint is wrapped as a Model Context Protocol server so any MCP-capable
agent (Claude Desktop, Claude Code, and others) can call it as a tool. Install:

npm install -g bsc-dex-spread-mcp

It is also available via Smithery
and the official MCP registry (io.github.donnywin85/bsc-dex-spread).

Then add it to your MCP client config, supplying your own buyer wallet:

{
  "mcpServers": {
    "bsc-dex-spread": {
      "command": "npx",
      "args": ["-y", "bsc-dex-spread-mcp"],
      "env": { "EVM_PRIVATE_KEY": "0xYOUR_BASE_MAINNET_BUYER_KEY" }
    }
  }
}

A note on the wallet model, because it matters: you supply the key; the package
ships none. The server signs each payment with the key in EVM_PRIVATE_KEY,
which you set in your own config. Fund that wallet with a few dollars of USDC on
Base and nothing else — the x402 exact scheme uses EIP-3009
transferWithAuthorization, so the facilitator broadcasts the transfer and pays
the gas. A zero-ETH wallet settles fine. Treat it as a disposable, low-balance
spending wallet.

Once configured, the agent has a get_dex_spread(pair, fee?) tool and pays
$0.01 USDC each time it calls it.

Proof it is live

Live usage/telemetry page: https://x402.donnyautomation.com/stats
First real mainnet settlement (self-payment, to prove the path end to end): 0x0c3ceda02f8aa36d48da392330e5bdcc9f34632a5dba2366a1663d6e7a301733 — Base mainnet, receipt status success. The transaction was submitted by the facilitator, confirming the buyer paid zero gas.

The /stats page shows challenge-versus-paid counts and recent settlements, so
you can watch real demand accrue rather than take my word for it.

Takeaway

If you are building agents that touch on-chain markets, this is a small, honest
example of the pattern worth copying: a narrow, useful data endpoint, priced per
call, discoverable and payable by machines without a human in the loop. The
protocol is x402; the packaging is MCP; the price is a cent.