Products Lemma APIProof issuance & verification platformTrust402Delegate to agents, and transactSealSign-in for the agent era — no keys handed over
Use cases Manufacturing & Critical InfraInspection Record AssuranceFinance & FinTechCounterparty Record VerificationPublic SectorCertificate-less ProceduresHealthcareQualified Worker AssuranceProcurement & Supply ChainSupplier Credential MonitoringMedia & ContentContent AuthenticityService & RetailCross-group IdentityAI Adoption (cross-industry)AI Run GovernanceDevelopers & Agent OpsAgent Authority Control ▸ Browse the use-case index
Pricing
Resources Critical BriefThe frontier of AI × trustBlogThinking and implementation notesDocumentationAPI & specsVerification CenterReal verification & issuance countsAbout usFRAME00, Inc.ContactSales & press inquiriesGlossaryDefinitionsFAQFrequently asked questions
Dashboard ↗ JA
Home / Critical Brief / No. 087
No. 087 Critical Brief · Verifiable Origin

Polymarket: JavaScript injected through a third-party vendor dependency asked users for fake approvals on the real site (BleepingComputer and others)

~$3M
Crypto assets (pUSD) drained from users' wallets (reporting)
Under 15accounts
Accounts that made the fraudulent approval and lost funds (reporting)
~1,893ETH
What the stolen pUSD was swapped into, then bridged from Polygon to Ethereum (traced by PeckShield and Bubblemaps)
CountryGlobal
Incident date2026-06-26
Published2026-06-30
AuthorsLemma Critical Team
Contents
  1. 01Summary
  2. 02What got through
  3. 03Pre-execution check
  4. 04What Lemma does
  5. 05Facts and timeline
  6. 06Sources

Summary

The attacker compromised a third-party vendor dependency loaded by Polymarket’s front end and injected JavaScript into the real site. When users opened the real site, the script ran in their browser and requested a fraudulent wallet approval that looked like a legitimate transaction. Polymarket’s backend, servers and smart contracts were not compromised. Even code served from the real domain can swap what users are asked to approve, unless the site checks, before asking for approval, that the code is what its operator shipped.

Exhibit 1Detection vs pre-execution check

A pre-execution check means checking, before asking users for approval, that the code running in the browser and the transaction to be approved are legitimate, and keeping a record. Detection means noticing after the approvals and the drain. Dates are those each party disclosed or published. The date the dependency was compromised has not been disclosed.

Pre-execution check · not known from the disclosuresBefore asking for approval, check that the code and the transaction are legitimate
What was confirmedAbout $3M drained
from under 15 accounts
Detection · worked after the drainRemove the dependency and trace the funds
Before 06-26
A third-party dependency is compromised (estimated)
06-26
Fake approvals are requested on the real site
06-26
Polymarket discloses and removes the dependency
06-29
Rescana publishes its analysis

What got through

What got through
Users’ fraudulent wallet approvals (transaction signatures). Users approved, believing it was an operation on the real site, and the approved transactions withdrew pUSD from their wallets.
What was not compromised
Polymarket’s backend, servers and smart contracts. The harm stayed within the front end and users’ operations (Polymarket).
What reached the receiving side
In general, a browser runs a script served from the real domain as that site’s code. What users see is the site’s screen and the wallet’s approval screen. Whether the code asking for approval is what the operator shipped cannot be told from the screen.
Not disclosed
Which vendor’s dependency was compromised, and how. When the injection began and how long the script ran (reporting estimates “before 2026-06-26”). Attribution: no high-confidence attribution to a specific actor has been made.

Pre-execution check

Whatever the route, the condition for telling them apart is that, before asking users for approval, the site checks, separately from whether the domain is real, that the code running in the browser is what its operator shipped and that the transaction to be approved was created through the legitimate business flow.

The core of this case
Even code served from the real domain can swap what users are asked to approve, unless the site checks, before asking for approval, that the code is what its operator shipped.
Who approves
The site operator. It registers the code it ships as its own, and registers only the approved versions of third-party dependencies.
Where it is checked
Before asking a user’s wallet for approval. An approval request from code that does not match the registration is not started. The transaction to be approved is also checked, separately from what the screen shows, for whether it came through the legitimate flow.
What is recorded
Which code, at which version, asked for approval of which transaction. It shows only that “this code is what the operator shipped,” without disclosing the whole delivery pipeline.

Detection worked after the drain and carried forward the scoping of the damage and per-account reimbursement. A similar case, where what the approval screen showed and what was actually approved diverged, is Bybit (JavaScript injected into the Safe{Wallet} front end). A case where code riding on a trusted channel was contaminated is the skimmer using Stripe’s trusted channel.

What Lemma does

Lemma puts the pre-execution check at the step where users are asked for approval. It does not replace checking that the domain is real; on top of that, before asking for approval, it checks that the code running in the browser is what the operator shipped and that the transaction to be approved came through the legitimate flow.

Industries and operations to watch

IndustryFinance
Services, such as crypto exchanges and prediction markets, that ask users’ wallets for approval from a web front end.
IndustrySupply chain
Websites whose front end loads dependency components supplied by third-party vendors.
OperationApprovals
Asking users to approve (sign) a transaction.

Current controls vs Lemma

The route in this case is column 1 (the wallet approval requested by code injected into the real site). Column 2 is understanding the damage after the drain; here, removing the dependency and tracing the funds worked.

Control Approval requested by injected code Understanding the damage after the drain
Domain legitimacy (TLS, how the URL looks) Not effective Not relevant
Users checking the approval screen Not effective Not relevant
Removing the dependency and tracing funds Not effective Effective
Lemma (pre-execution check) Effective Partial

Domain legitimacy shows where the site is, not whether the code riding on it is what the operator shipped. Users operated a real-looking screen on the real domain, and the object of approval was swapped from inside the site. Removing the dependency and tracing the funds carried forward the scoping of the damage and per-account reimbursement, but did not stop the withdrawals once the approvals went through. Lemma checks, before asking for approval, that the code running in the browser is what the operator shipped and that the transaction came through the legitimate flow. A record of which code asked for which approval is kept, so it can also help in understanding the damage afterwards.

Note: Lemma’s check works only when it is built into the mechanism that asks users for approval, and the registration of shipped code and approved dependencies is managed outside the delivery path. If the registration itself is compromised, or malicious code sits inside an approved version of a dependency, this check can be passed. How the dependency was compromised has not been disclosed. The table compares what each control checks; it does not show whether this incident would have been stopped. Lemma does not detect or prevent intrusions.

CheckChecklist

Three things to confirm for organizations that ask users for approval from a web front end

  • Before asking for approval, do you check that the code running in users’ browsers is what you shipped (including approved versions of third-party dependencies)?
  • Do you check, separately from what the screen shows, that the transaction to be approved came through the legitimate business flow?
  • Do you limit the third-party dependencies your front end loads to approved versions, and notice when they change?

Facts and timeline

Service
The web front end of Polymarket (a crypto-based prediction-market platform) and its users’ wallets.
Scale of loss
About $3 million worth of crypto assets. Fewer than 15 accounts were affected.
Origin of the compromise
A third-party vendor dependency component (a software dependency) loaded by the front end was compromised. This corresponds to MITRE ATT&CK T1195.002 (Supply Chain Compromise: Compromise Software Dependencies and Development Tools) (Rescana).
Method
Through the compromised dependency, JavaScript was injected into Polymarket’s real site. When users visited, the script ran in their browser and requested a fraudulent wallet approval that looked like a legitimate transaction (T1059.007 JavaScript, T1189 Drive-by Compromise, T1566.002 phishing via service; Rescana).
Flow of funds
What was stolen was Polymarket’s settlement stablecoin pUSD (Polymarket USD, USDC-collateralized). The attacker swapped it into about 1,893 ETH and bridged it from Polygon to Ethereum (traced by PeckShield and Bubblemaps).
Not compromised
Polymarket’s backend, servers and smart contracts.
Context
The method is the same type as Magecart-style JavaScript injection aimed at e-commerce and crypto platforms, and no high-confidence attribution to a specific actor has been made.

Glossary
Dependency component — A part, such as a script, supplied by a third-party vendor and loaded by a website's front end. Once loaded, it runs in the browser with the same rights as the site's own code.
Wallet approval — Signing a transaction in a crypto wallet to authorize it. An approved transaction can move assets out of the wallet.
pUSD — Polymarket's settlement stablecoin (Polymarket USD, USDC-collateralized). ParionUSD and ParyonUSD in some reporting refer to the same token.

Timeline

Before 2026-06-26 (estimated)
A third-party vendor dependency loaded by the front end is compromised, and JavaScript is injected into the real site.
2026-06-26
The injected script runs in users’ browsers; fewer than 15 accounts make fraudulent approvals and about $3 million worth is drained. The pUSD is swapped into about 1,893 ETH and bridged from Polygon to Ethereum.
2026-06-26
Polymarket discloses the case. BleepingComputer and OffSeq Radar report it. Polymarket announces removal of the affected dependency and full reimbursement.
2026-06-29
Rescana publishes a structural analysis of the supply chain (citing the tracing by PeckShield and Bubblemaps).

The scale and attribution draw on Polymarket’s disclosure and external analyses (Rescana, BleepingComputer, PeckShield, Bubblemaps). This Brief records the values confirmable at the time of investigation and makes the sources explicit. The stolen stablecoin is Polymarket’s settlement pUSD (Polymarket USD, USDC-collateralized); ParionUSD and ParyonUSD in some reporting are naming variations of the same token. What has not been disclosed does not mean there were no controls.

After disclosure

  • Polymarket: Disclosed the case and removed the affected third-party dependency from its systems. Notified affected users and announced full reimbursement. Confirmed that the backend and smart contracts were not compromised.
  • Rescana: Published a structural analysis of the supply chain, mapping it to MITRE ATT&CK (T1195.002 and others) and generalizing the risk of third-party dependencies.
  • PeckShield / Bubblemaps: Traced the flow of funds, including the pUSD-to-ETH swap and the Polygon-to-Ethereum bridge.
  • Industry point: Because DeFi and crypto platforms have many third-party dependencies and users’ operations pass through web wallets, continuous auditing of front-end dependencies, integrity checks of shipped code, and user awareness (how to spot suspicious approval requests) were again shared as points of defense.

Sources

References: “The last layer left in AI-era cyber defense”

The same method elsewhereSee all 32 "Supply chain" cases

This Brief sets out, from disclosed facts, what organisations in a similar position can check. It is not guidance on individual losses or procedures.

This material is a structured analysis of public information; it is not an audit, diagnosis, or recommendation for any specific organization.

Cite this Brief

Lemma Critical Team. (2026).
"Polymarket: JavaScript injected through a third-party vendor dependency asked users for fake approvals on the real site (BleepingComputer and others)".
Lemma Critical Brief No.087. Lemma / FRAME00, Inc.
https://lemma.frame00.com/critical/briefs/087-polymarket-frontend-supply-chain/
Read nextNext
All Briefs →
Lemma

If it can't be verified,
it doesn't enter your operation.

Lemma is a pre-execution check: logins, payments, records and publishing that look genuine are checked before they run, with cryptographic proofs the receiving side verifies without asking the issuer. Detection stays; the check sits in front of it.