On Thursday, October 29, 2026, Polymarket halted trading on its international exchange for about an hour. At the center of it was a script Polymarket loaded from DebugBear, a UK website performance monitoring company. According to independent teardowns, the file served from DebugBear’s CDN had become a wallet drainer: it looked for signed-in traders, tried to sell their positions and sent the proceeds to an attacker’s wallet. Polymarket puts the theft at $2.7 million across 726 wallets and says it has refunded almost all of them.

Below is what is confirmed, what is only reported, how the code worked, and what any team that loads third-party JavaScript into a signed-in app should change.

What we know

  • Polymarket confirmed a third-party compromise. “One of our 3rd party providers was compromised, and we have referred this to relevant law enforcement,” it posted on X, adding that “out of an abundance of caution, we have temporarily halted trading.” After trading resumed it said it is “fully reimbursing all affected traders” (NBC News). It referred the case to UK law enforcement.
  • Refunds are nearly done. On October 30 Polymarket said 689 of 726 affected wallets had been refunded in full and the other 37 were being paid as each is verified. It is also paying $1.19 million to about 5,500 wallets that lost money during the pause or had positions taken, for $3.9 million in total, with “No claims or tickets needed” (Polymarket on X). It said earlier on Discord that losses under $10,000 would be restored by October 30 and that anyone who lost more must sign a release form (CNBC). A user posted a document labeled a settlement and release agreement (TokenPost), and Bankless reports that terms shared by users included ID checks and a broad non-disparagement clause. Polymarket has not publicly addressed them.
  • The provider was DebugBear. A source familiar with the matter named DebugBear to Reuters and CNBC. DebugBear posted on X: “We’re impacted by an ongoing security incident. If you use our RUM product, please remove the embed code from your website.” Polymarket’s own production build carries a commit titled “remove debugbear rum script” (Hudson Rock).
  • The malicious file came from DebugBear’s CDN. Hudson Rock downloaded cdn.debugbear.com/C7xcKKrjUnXK.js twice, at 18:12 and 18:13 UTC, and got the same 15,187-byte drainer both times.
  • Polymarket puts the theft at $2.7 million from 726 wallets. That is close to the independent counts. Bitquery traced $2.73 million from 737 accounts in about an hour, plus open positions from 33 accounts, with a median loss of $171. Bubblemaps, Betting Intelligence and Polysights each reached about $2.7 million (RG.org). Polymarket says it removed the provider “within the hour”, which fits the 49 minutes between the first stolen funds and its fix build.
  • Polymarket US was not compromised, a person familiar with the matter told CNBC. The halt covered the international platform, Polymarket.com.
  • DebugBear is back online, without a post-mortem. Its hostnames stopped resolving on the evening of October 29 and stayed down until DebugBear’s registry record changed at 13:35:50 UTC on November 2, with new Cloudflare nameservers. At 18:14 UTC on November 3, www, cdn, eu-cdn, data and status.debugbear.com resolved again and app still did not. Its homepage says it is “continuing to investigate the recent security incident and will provide an update soon”. After its first notice it posted twice: at 22:16 UTC on October 29, saying it has “engaged specialist cyber incident response support” and “will work with affected customers directly” (DebugBear on X), and at 23:11 UTC on October 30, with its first account of the cause (DebugBear on X).
  • DebugBear says the attacker went through its registrar. “Our DNS server records were compromised through our domain registrar,” it posted on October 30, adding that it has “not seen any indication of a compromise of our internal systems, though we will continue to investigate this” (DebugBear on X). A customer had written on the afternoon of the attack that “DebugBear reported a security incident: its domain was taken over” (pull request). The public registry record for debugbear.com was changed at 16:45:50 UTC on October 29, 25 minutes before the first stolen funds moved and nine minutes before Cloudflare lost the script’s origin. It did not change again until 13:35:50 UTC on November 2, when DebugBear came back online with new Cloudflare nameservers. WHOIS lists Namecheap as the registrar. DebugBear has not said how the attacker got into its registrar account, or whether the registrar itself was at fault.
  • Still unknown: how the attacker got into DebugBear’s registrar account. DebugBear says its initial investigation shows the attack “targeted the website of a specific customer”, and the code agrees. The drainer was written for Polymarket alone: it reads Polymarket’s storage keys, calls its APIs and looks for its trading client (Ohey). Neither Hudson Rock nor DeFiprime found public evidence of other victims. The October 27 date is a date on the attacker’s file: Internet Archive copies of Polymarket’s script were still clean at 12:06:55 on October 29.

Timeline

All times October 29, 2026, unless marked. Eastern Time was UTC−4.

UTCETEventSource
12:068:06 a.m.The Internet Archive captures Polymarket’s script, still DebugBear’s clean file.Internet Archive; checked by us
16:4512:45 p.m.The public registry record for debugbear.com shows its last change. It does not say what changed.Our registry lookup
16:5412:54 p.m.Cloudflare returns error 521 for the script URL: it can no longer reach the origin.Internet Archive, Ohey; checked by us
17:10–18:101:10–2:10 p.m.Stolen funds reach the attacker’s Polygon address: first POL at 17:10:23, first batch of outcome tokens at 17:26:29, last token transfer at 18:02:56, last POL by 18:10:29.DeFiprime; block times checked by us
17:481:48 p.m.Polymarket users report on Discord that the front end may be compromised and assets are leaving their accounts.AggrNews on X
17:591:59 p.m.Timestamp of a Polymarket production build whose commit reads “chore(polymarket): remove debugbear rum script”. A build time, not proof of when it was deployed.Hudson Rock
18:012:01 p.m.DebugBear posts that it is impacted by an ongoing security incident and asks RUM customers to remove its embed code.DebugBear on X
18:052:05 p.m.Polymarket’s status page puts the exchange in cancel-only mode and pauses relayer actions.Unchained
18:102:10 p.m.Polymarket’s relayer sends its last transaction before the pause, at 18:10:35. It resumes at 18:52.Bitquery
18:122:12 p.m.Hudson Rock downloads the drainer from cdn.debugbear.com, twice, with identical bytes.Hudson Rock
18:28–18:382:28–2:38 p.m.The suspected attacker wallet sends out about 28.6 million POL in three transfers.RG.org, from Polygonscan
18:332:33 p.m.Polymarket confirms a third-party provider was compromised and says anyone affected “will be made whole”.Unchained
18:562:56 p.m.Binance founder Changpeng Zhao quotes the Discord report, links DebugBear’s notice and calls it “an injection attack on the front end”.CZ on X
~19:00~3:00 p.m.Trading resumes. Polymarket says it is fully reimbursing all affected traders.NBC News, Unchained
19:053:05 p.m.The status page marks the incident resolved.Unchained
20:054:05 p.m.XRP starts leaving Binance wallets, the first theft in Binance’s incident. A separate incident, covered below.TRM Labs; checked by us
20:214:21 p.m.Binance’s Ethereum hot wallet is taken over; the first sweep follows at 20:24.Our on-chain timeline
21:505:50 p.m.cdn.debugbear.com and data.debugbear.com no longer resolve (NXDOMAIN from both Cloudflare and Google public DNS).Our own check
22:166:16 p.m.DebugBear posts again: it has engaged specialist incident response support and will work with affected customers directly.DebugBear on X
Oct 30, 01:459:45 p.m.Every DebugBear hostname we checked except www returns NXDOMAIN, including its app and status page. www.debugbear.com returns Cloudflare error 1016.Our own check
Oct 30, 14:3710:37 a.m.Polymarket says 689 of 726 affected wallets are refunded, $3.9 million in total with pause-related losses, and promises a postmortem.Polymarket on X

What the script did

Three teardowns of the file have been published: Hudson Rock, Dancho Danchev and DeFiprime. None reports running it against a live account, so this is what the code was written to do, not proof that every step worked.

  1. Decide whether to run. It fetched settings from data.debugbear.com, with hard-coded fallbacks: a recipient wallet, a $10 minimum portfolio and a $10 minimum position. It also called Polymarket’s own geoblock endpoint and quit for visitors Polymarket blocks from trading.
  2. Read the session. It read three Polymarket entries from the browser’s localStorage (polymarket.auth.params, polymarket.auth.proxyWallet and poly_clob_api_key_map) to learn the trader’s wallet and account type.
  3. Find the trading client inside React. It walked React’s internal component tree and hook state until it found an object with postOrder, createOrder and createMarketOrder methods, then used that object and its signer.
  4. Take inventory and report it. It read up to 200 positions and the account’s pUSD and USDC.e balances, then posted the wallet address, IP address, country, operating system, account type and portfolio value to data.debugbear.com/metrics/submit.
  5. Move the cash. It built an EIP-712 signed batch for the trader’s Polymarket deposit wallet and submitted it through Polymarket’s own relayer: unwrap pUSD to USDC.e, then swap it to the recipient through a third-party route. If no route answered, it fell back to a plain USDC.e transfer.
  6. Liquidate positions. For traders using their own external wallet, it batch-transferred the outcome tokens straight to the recipient through Polymarket’s relayer, a step that put a signature request in front of the trader (DeFiprime). For email-login accounts, it placed fill-and-kill sell orders at about 97% of the price, then 50%, then the minimum tick, with no prompt at all, and then tried to withdraw the proceeds.

Two details matter more than the rest.

It did not need passwords or keys. None of the analysts found code that exfiltrates credentials, seed phrases or private keys; DeFiprime notes it used the trader’s API credentials in place rather than sending them anywhere. The trader was already signed in, and a script running in the page has the same authority as the page’s own code. Every order and transfer was signed by the page’s own signer and sent to Polymarket’s own trading API or relayer.

Its traffic looked like monitoring traffic. Settings and reports went to DebugBear’s own data host under /metrics/ paths: the same kind of request a RUM script sends on every page view.

Hudson Rock and Danchev also found bugs. The code counts “submitted” and “pending” relayer states as success, and one balance check compares a value with itself. The attacker’s own reports may overstate what happened; the on-chain totals are the better measure.

Why the usual defenses did not stop it

Content Security Policy decides which origins may run code and receive requests. cdn.debugbear.com was allowed because Polymarket chose to load it, the data host was allowed because a RUM script has to send its data somewhere, and the money moved through Polymarket’s own relayer. Every other host the drainer called, including the third-party swap service, was already on Polymarket’s policy (Ohey), and the code had a fallback that needed no outside service. CSP controls where code comes from, not what allowed code does.

Subresource Integrity pins a script to a hash, and the browser refuses a file that changed. It only works for a file that never changes. Most analytics and RUM snippets load a file the vendor updates in place, so the vendor can ship fixes without waiting for your deploy. That design is convenient, and it means the vendor, or whoever controls the vendor’s CDN, can change the code running on your page at any time.

Vendor review would have passed. DebugBear is a legitimate, widely used performance tool. The risk was never the vendor’s intent. It was that anyone who controls the file controls your page, with your user’s session.

Polymarket has been here before

On June 25, 2026, Polymarket said a third-party vendor had been compromised and malicious code injected into its front end. About $3 million was taken; Bubblemaps concluded that fewer than 15 accounts were affected, and Polymarket said it was refunding them in full (Decrypt). Polymarket did not name that vendor, and nothing published links it to DebugBear. In May, a separate incident drained an internal rewards wallet through a compromised private key.

That makes two front-end vendor compromises at Polymarket in four months. In an app where a signed-in page can sign transactions, every script on that page is effectively a co-signer.

Was Binance hit by the same attack?

Nothing published says so. Binance lost far more the same afternoon, so the two are being reported together, but the evidence so far points to two unrelated attacks.

  • Where the link came from. At 18:56 UTC, Binance founder Changpeng Zhao quoted a report of Polymarket users losing funds and wrote that it “seems to be caused by” a link to DebugBear’s notice: “it appears to be an injection attack on the front end. injecting incorrect tx, but showing a valid tx for the user to sign” (X). He was describing Polymarket. Binance’s own trouble started about 70 minutes later.
  • What happened at Binance. Binance dates the compromise to around 20:05 UTC (Binance Update #2). TRM Labs traced about $6.36 billion out of its wallets on ten blockchains, starting with XRP, and Elliptic counts $6.43 billion on 11. On Ethereum, an attacker took over the hot wallet labeled “Binance 14” at 20:20:59 and swept out 167,464 ETH and 1.6 billion USDT at 20:24:23. Six more sweeps followed, including 823 million USDC, before Binance revoked the takeover at 00:10:35 (our block-by-block timeline). Binance puts the total impact at about $6.3 billion, with about $3 billion frozen; TRM counted about 1.77 billion USDT frozen by Tether and about 825 million USDC by Circle. Withdrawals are still paused, with a phased restart targeted for early on November 1. Binance says deposits are unaffected, says it will cover all losses and has promised a post-mortem.
  • How it worked looks nothing like Polymarket. Binance says its initial investigation points to a compromised DevOps engineer’s laptop, which let the attacker into a service container that could submit withdrawal transactions, and that it found no evidence of a private key leak (Binance on X). It has since said it found “additional points of breach” (X), and TRM Labs assesses that the attacker could make Binance’s hot wallet signing system sign across chains. On-chain, that access was used to hand one wallet to a “sweeper” contract through an EIP-7702 authorization, the one hit among 50 the attacker sent in a single transaction (Blockaid). No report ties it to a browser, a third-party script or DebugBear. Binance’s initial report on November 3 traces the access to a fake job interview, a tampered developer tool and an internal AI tool, and does not mention Polymarket or DebugBear.
  • No one has drawn a link. TechCrunch called Polymarket’s breach “a separate incident”, Blockhead wrote that “no link between the two incidents has been established”, and neither company has suggested one. TRM Labs attributes Binance’s theft to North Korea’s TraderTraitor with high confidence, and Chainalysis reaches the same view (Decrypt). Elliptic calls North Korean involvement likely but not certain. On October 31 the FBI said North Korea was responsible for the Binance theft and named the activity TraderTraitor. TRM’s report does not mention Polymarket or DebugBear, and no one has attributed Polymarket’s theft.

The two do share a lesson. Polymarket’s drainer, and Binance’s attacker by Binance’s own account, both got a legitimate signer to sign something its owner never meant to. That is also how Bybit lost $1.5 billion in February 2025: malicious JavaScript planted in Safe{Wallet}’s web interface showed Bybit’s signers one transaction and had them sign another (BleepingComputer). No key was stolen at Polymarket or Bybit, and Binance says it found no evidence its key leaked. The weak point was the software that decides what gets signed. Binance’s takeover also left a public mark on Ethereum minutes before that wallet was drained; our follow-up shows the block-by-block timeline and the check that alerts on it.

What to change in your own app

  1. List every third-party script on your signed-in pages. Open the network panel on your most sensitive page (checkout, payouts, account settings) and filter for JavaScript from other domains, including everything a tag manager pulls in. A Content Security Policy in report-only mode with a reporting endpoint gives you the same list from real traffic.
  2. Take them off pages that can move money or data. Analytics, RUM, chat and A/B testing earn their place on marketing pages and most of a product. They do not need to run where a session signs a transfer, changes a payout account or exports customer data. Put that step on a separate origin, or in an iframe that loads no third-party code.
  3. Bundle what you keep. A vendor SDK installed from npm and built into your own bundle runs the version in your lockfile, not whatever the vendor’s CDN serves today. A compromised package can still reach you, but only through an upgrade you choose and can diff.
  4. Pin and hash what you cannot bundle. Load a versioned URL with an integrity hash and crossorigin="anonymous". If a vendor only offers a moving “latest” URL, treat it as code that vendor can change on your page whenever it likes, because it can.
  5. Make high-risk actions prove intent. The drainer needed no new permission; it used the session the trader had already opened. Step-up confirmation for withdrawals, transfers to new addresses and bulk sells at far below market raises the bar for any script running in the page.
  6. Know how fast you can pull a tag. Time the path from “vendor compromised” to “tag gone from production”, including CDN and HTML caches. Removing the tag is the one fix you control: stolen funds were arriving on-chain for 49 minutes before Polymarket’s fix build and for about 11 minutes after it, and Hudson Rock could still download the drainer from DebugBear’s CDN about 12 minutes after DebugBear’s notice.
  7. Follow your vendors’ incident channels. DebugBear’s notice went out on X. If no one on your team follows each script vendor’s status page or account, you hear about their incident from the news, or from your users.
  8. Lock down your own domain. DebugBear says the attacker came in through its registrar, and Kintsu’s site was hijacked at its registrar a day later. Whoever controls your registrar account controls where your domain points, including the hosts that serve your scripts and receive your email. Turn on two-factor authentication and transfer lock at your registrar, ask whether it offers registry lock, and get alerted when your nameservers change. Site Qwality’s domain monitoring reads the registry once a day and alerts when the registrar or nameservers change. That makes it a backstop, not an alarm within minutes: Polymarket’s drain began 25 minutes after DebugBear’s record changed.
  9. Watch the script itself, from outside. Polymarket’s script URL returned a 521 error 15 minutes before the first theft, then served a 15,187-byte file in place of a 60,493-byte one. A Site Qwality HTTP check on a vendor’s script URL, with a Keyword assertion on text from the real file (Polymarket’s carried its snippetKey), alerts you when the file stops loading or stops being the file you expect. It will not tell you why, and the archive shows only one moment of that 521, so we cannot say how long it lasted. But it is a signal from your own monitoring rather than from the news. See the HTTP check reference.

If you use DebugBear RUM

  • Keep the embed code out until DebugBear says otherwise. DebugBear asked customers to remove it, and it has not withdrawn that advice. Its script hosts resolve again: at 18:14 UTC on November 3, Polymarket’s script URL served an ordinary RUM file from Google Cloud Storage. That tells you what the file was at one moment, not who controls it next. Before you add the tag back, wait for DebugBear’s explanation, then pin it with an integrity hash or watch the file from outside.
  • Review signed-in activity from the morning of October 29 at least. The evidence puts Polymarket’s drainer live from about 16:54 UTC that day, but the archive sampled that one URL about twice a day and says nothing about your own script file. Go back further if your logs show anything odd.
  • Block or alert on these indicators, published by Hudson Rock and Dancho Danchev:
TypeIndicator
Scriptcdn.debugbear.com/C7xcKKrjUnXK.js
SHA-256 of the script0755e767504d8103f6c27b9e765a1026507a17c04513242adb503df7777879e5
Settings and reportingdata.debugbear.com/metrics/init
data.debugbear.com/metrics/submit
data.debugbear.com/metrics/update
data.debugbear.com/metrics/handle
Fallback recipient (Polygon)0x3F99139F1C5854bb628c2e576Aaf638e99dFfc18
Tracking ID4c6b64a0-a7ef-4c0f-9c70-3a4e6f89065c

We ship a RUM script too

Site Qwality sells real user monitoring, and our CDN snippet loads a file from cdn.siteqwality.com that we update to ship fixes. That is the same trust Polymarket placed in DebugBear, and the same trust you place in every vendor tag on your site. If you would rather not extend it on your most sensitive pages, you do not have to:

  • Install from npm. @siteqwality/rum builds the SDK, session replay recorder included, into your own bundle at the version in your lockfile. Our CDN then serves your application’s settings as data, never code. See the RUM quickstart.
  • Leave it out where it does not belong. If your payment or signing step lives on its own origin or iframe, do not load the SDK there. The rest of your app still gets page views, Web Vitals, errors and replays.
  • Lock down where it can talk. Our CSP guide lists every host the SDK uses, so your policy can allow exactly those and nothing else.

Sources