DEV Community

198 Calls, 198 Wallets, One Address: What a Verifier Looks Like in Your Ledger

This content reflects minia2a as of its publication date and is kept for the record. Current model: x402 pay-per-call in USDC on Base only, 5 free trial calls per signed wallet, no credits and no top-up rail.

November 19, 2026

A marketplace's ledger records what each caller did. It rarely records who the caller is, and today that gap had a concrete shape on our own gateway: one address, 198 calls, 198 distinct wallets, 39 different endpoints, all inside eleven hours.

Every one of those calls arrived between 2026-11-18 13:17:22 and 2026-11-19 00:10:42 UTC. Each carried a fresh wallet identity - 198 calls, 198 distinct agent ids, no repeats.

That is not how a buyer behaves, and it is worth writing down why, because the same shape will show up in any pay-per-call system that hands out a free tier.

The shape, in numbers

Measure Value
Calls from the address 198
Distinct wallets (agent ids) 198 (one call each)
Distinct services touched 39
Delivered (ok) 64
Refused (refused, HTTP 400) 123
Failed (failed) 11
Window 10 h 53 m

Sixty-two percent of the calls were rejected, and the rejections are the interesting part. The most common single input across the whole run was an SSRF payload:

Rejection text (truncated) Calls
invalid url: private IP blocked 65
invalid url: resolves to private address 18
http(s) url required 7
host is not a resolvable public host 7
internal address / private/internal IP blocked 8

That distribution is a fuzzer's distribution, not a user's. A buyer who wants to fetch a page sends one URL and it works. These calls walk the input space: private ranges, link-local targets, non-resolvable hosts, empty parameters - each call wearing a different wallet, which also means a per-wallet free tier never runs out.

All 198 calls were free: 192 trials and 6 first-call allowances. Not one was paid.

The eleven failures are almost entirely upstream: ten timeouts across three fetch-style endpoints and one PDF parser that was not available. Those are the ones that are not the caller's doing, and they are also the only honest signal in the run - a target that did not answer inside the deadline.

Why this matters beyond the curiosity

Any pay-per-call marketplace computes some per-seller reliability number, and the cheapest formula uses call outcomes. If refused counts as a failure, then 123 of this stranger's inputs became some seller's problem - and the seller never saw the call.

We hit exactly this. Our score is effective = paidAttempts − callerRefused, which subtracts caller-caused refusals from the denominator. That works only if the ledger knows a refusal was the caller's fault.

Dropping the outcome-based rule and reading our own 90-day ledger shows the gap:

90-day rows Count
paid / ok 292
paid / refused 94
paid / failed 25
of those, error text is unambiguously caller-shaped 19
of those, ambiguous (a captcha type needing extra emulation fields) 2
of those, genuinely upstream/service 4

The nineteen unambiguous failed rows read like this: xml required, invalid date, country name required, token must be 0x address, Unsupported type: recaptcha-v2. Every one is a caller mistake stored under an outcome that means delivery failure.

The distinction cannot be recovered after the fact by reading free text - which is the real lesson.

Write the cause where the error is raised

The fix is one line in the place that knows: when a handler rejects input, it should say so in the response, not leave the caller/seller question to be guessed by whoever reads the row later. We use a cause field on the failure envelope - caller for input the caller got wrong, platform for our own deadline, service for the target misbehaving - and the ledger copies it.

The same rule applies to delisting. A seller whose target times out twice should not lose the listing because a third call happened to time out too; a seller whose handler always times out should. Those two rows look identical if the only column you keep is outcome=failed:

-- the row that distinguishes them
SELECT service_id, cause, error, count(*)
FROM delivery_outcomes
WHERE outcome = 'failed'
GROUP BY service_id, cause, error;
-- without `cause`, this is all you have, and it is not enough
SELECT service_id, count(*)
FROM delivery_outcomes
WHERE outcome = 'failed'
GROUP BY service_id;

What we are not claiming

We do not know who ran it. The address is a normal hosting provider, the User-Agent is Python-urllib/3.12, and every call is a trial. It could be a directory verifying listings, a security scan, or a competitor sampling prices.

The classification here is behavioural, not attributional: one address, one call per wallet, 39 services, a fuzzer's input distribution.

What we can claim is narrower and useful: the shape is unambiguous in our ledger, and the ledger now records enough to tell a stranger's probe from a seller's defect. That is the difference between running a marketplace and running a scoreboard for whoever is probing it.

Originally published at minia2a.uk.

Read on DEV Community ↗ ← Back to News

Comments

No comments yet. Start the discussion.