corporate business

cryptocurrency blockchain

government public service

e-commerce shopping

Chinese

The domain 'todaypoly.com' uses the commercial generic top-level domain (.com) with no subdomain. The core label 'todaypoly' covers 9 characters containing three vowels alongside 6 consonants. Word splitting yields two words: today, poly. Expect 4.5 characters per word on average. No strong language cues emerged from the frequency lists.

html/fb/94/fb94f641-ebf0-4a3f-8092-357b522a59dc.html.gz

c25853fd31addfce188b01061fe85bfe667d5fb6c7a7bbb1c83d0ddfd8627acc

db1a98964d51c8a36f609efe2d078909bce7bd700de0da9e9d76d9fb736be1f0

14d22e8504cf5287c39871de0c75cc06bb1431199c233de29fd789afbede547e

de4ad97781df51fc7b665b855e021b6a54db68ef43bf5420f7145fe1a74fd76b

5481664137fd9205187d74458283c56a167d0d71aabaaac1d1123c0aca8e3e0f

5cd2819d92541e16cf5820a686f3c7e8bfa275b120929fa0d470f34cabaeb4a3

f8af69cd448dccb558cfc06ad6f1bfd5a45be9614635e851d9ed0e612154329b

1f406b72127dbd2b66afb94c68af626ed08c93af468069890c33152907f957df

e1748051e7d122ce20871c8e5d8b6bb5ed14ca3d70c1aa311e88b55185f11d67

88de60959cde9dfad11f76df1d8b56f49954f56eb1488d6be5002b66a9af8661

c4347e70b840f38a15e3b258e625be6691fa1231e3d38ff854be806f0a2dff60

俄罗斯和乌克兰能否在2026年底前实现停火？

viewport

csrf-token

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

html/fb/94/fb94f641-ebf0-4a3f-8092-357b522a59dc_nodriver.html.gz

PolyShop - 预测市场

GoDaddy.com, LLC

TODAYPOLY.COM

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


      // 立即执行，确保在所有模块加载前就设置好全局对象
      // 简化版本，避免循环引用
      (function() {
        'use strict';
        
        // 只在浏览器环境中执行
        if (typeof window === 'undefined') return;
        
        // 确保 globalThis 存在（避免循环引用）
        if (typeof globalThis === 'undefined') {
          try {
            Object.defineProperty(window, 'globalThis', {
              value: window,
              writable: true,
              configurable: true
            });
          } catch (e) {
            window.globalThis = window;
          }
        }
        
        // 确保 global 存在（指向 window，避免循环引用）
        if (typeof global === 'undefined') {
          try {
            Object.defineProperty(window, 'global', {
              value: window,
              writable: true,
              configurable: true
            });
          } catch (e) {
            window.global = window;
          }
        }
        
        // 确保 globalThis.global 存在（避免循环引用）
        // 注意：不要设置 globalThis.global = globalThis，这会导致循环引用
        if (typeof globalThis !== 'undefined' && typeof globalThis.global === 'undefined') {
          try {
            // 直接使用 window，避免循环引用
            Object.defineProperty(globalThis, 'global', {
              value: window,
              writable: true,
              configurable: true
            });
          } catch (e) {
            // 如果 defineProperty 失败，使用直接赋值
            globalThis.global = window;
          }
        }
        
        // 确保 process 存在
      if (typeof process === 'undefined') {
        window.process = { env: {} };
      }
        if (typeof globalThis !== 'undefined' && typeof globalThis.process === 'undefined') {
          globalThis.process = window.process;
        }
        
        // 确保 Request 和 Response 在 globalThis 中可用（解决 axios 错误）
        if (typeof window.Request !== 'undefined') {
          if (typeof globalThis !== 'undefined' && typeof globalThis.Request === 'undefined') {
            try {
              Object.defineProperty(globalThis, 'Request', {
                value: window.Request,
                writable: true,
                configurable: true,
                enumerable: false
              });
            } catch (e) {
              globalThis.Request = window.Request;
            }
          }
        }
        
        if (typeof window.Response !== 'undefined') {
          if (typeof globalThis !== 'undefined' && typeof globalThis.Response === 'undefined') {
            try {
              Object.defineProperty(globalThis, 'Response', {
                value: window.Response,
                writable: true,
                configurable: true,
                enumerable: false
              });
            } catch (e) {
              globalThis.Response = window.Response;
      }
          }
        }
      })();
      
      // 先定义 stream，这样 require 函数可以使用它
      // 定义 stream 相关的 polyfill（用于 readable-stream）
      // 需要提供真正的类，而不是函数，以便可以正确继承
      if (typeof stream === 'undefined' && typeof window.stream === 'undefined') {
        // 创建可继承的基类
        class StreamBase {
          constructor() {
            this._writableState = {};
            this._readableState = {};
          }
          pipe() { return this; }
          on() { return this; }
          once() { return this; }
          emit() { return this; }
          end() { return this; }
          write() { return true; }
          read() { return null; }
        }
        
        class Readable extends StreamBase {
          constructor(options) {
            super();
            this.readable = true;
            this.readableEnded = false;
            this.readableFlowing = null;
            this.readableHighWaterMark = options?.highWaterMark || 16384;
          }
        }
        
        class Writable extends StreamBase {
          constructor(options) {
            super();
            this.writable = true;
            this.writableEnded = false;
            this.writableFinished = false;
            this.writableHighWaterMark = options?.highWaterMark || 16384;
          }
        }
        
        class Duplex extends Readable {
          constructor(options) {
            super(options);
            this.writable = true;
            this.writableEnded = false;
            this.writableFinished = false;
          }
        }
        
        class Transform extends Duplex {
          constructor(options) {
            super(options);
          }
        }
        
        class PassThrough extends Transform {
          constructor(options) {
            super(options);
          }
        }
        
        window.stream = {
          Readable: Readable,
          Writable: Writable,
          Transform: Transform,
          Duplex: Duplex,
          PassThrough: PassThrough,
          Stream: StreamBase
        };
        
        if (typeof globalThis !== 'undefined') {
          globalThis.stream = window.stream;
        }
      }
      
      // 定义 require polyfill（简单的实现，用于 Web3.js）
      if (typeof require === 'undefined') {
        window.require = function(module) {
          // 简单的 require polyfill，主要用于 Web3.js 内部使用
          // 如果模块已经在全局作用域中，返回它
          if (module === 'buffer') {
            return typeof Buffer !== 'undefined' ? Buffer : {};
          }
          if (module === 'process') {
            return window.process || { env: {} };
          }
          if (module === 'stream' || module === 'readable-stream') {
            // 优先使用全局 stream
            if (window.stream) {
              return window.stream;
            }
            if (typeof stream !== 'undefined') {
              return stream;
            }
            // 如果 stream 还没定义，返回一个基本的实现
            class StreamBase {
              constructor() {
                this._writableState = {};
                this._readableState = {};
              }
              pipe() { return this; }
              on() { return this; }
              once() { return this; }
              emit() { return this; }
              end() { return this; }
              write() { return true; }
              read() { return null; }
            }
            const streamImpl = {
              Readable: class extends StreamBase {},
              Writable: class extends StreamBase {},
              Transform: class extends StreamBase {},
              Duplex: class extends StreamBase {},
              PassThrough: class extends StreamBase {},
              Stream: StreamBase
            };
            // 缓存到 window.stream
            window.stream = streamImpl;
            return streamImpl;
          }
          // 对于其他模块，返回一个空对象以避免错误
          console.warn('require called for unknown module:', module);
          return {};
        };
        if (typeof globalThis !== 'undefined') {
          globalThis.require = window.require;
        }
      }
      
      // 定义 exports 和 module.exports polyfill（CommonJS 支持）
      if (typeof exports === 'undefined') {
        window.exports = {};
        if (typeof globalThis !== 'undefined') {
          globalThis.exports = window.exports;
        }
      }
      
      if (typeof module === 'undefined') {
        window.module = { exports: {} };
        if (typeof globalThis !== 'undefined') {
          globalThis.module = window.module;
        }
      }
      
    


      // 确保 Buffer 在全局可用
      if (typeof Buffer !== 'undefined') {
        window.Buffer = Buffer;
        if (typeof globalThis !== 'undefined') {
          globalThis.Buffer = Buffer;
        }
      }
    


      window.FACEBOOK_APP_ID = '804970132307335';
      // Twitter/X Client ID 配置
      // 请将 YOUR_TWITTER_CLIENT_ID 替换为您的 Twitter Client ID
      window.TWITTER_CLIENT_ID = 'YOUR_TWITTER_CLIENT_ID';
    

Requests	IP Address	Location	AS Autonomous System
8	61.111.250.101	South Korea	AS138195MOACK.Co.LTD
7	142.251.127.84	United States	AS15169Google LLC
7	156.254.5.157	Hong Kong	AS139923ABCCLOUD SDN.BHD.
7	151.101.65.229	Unknown	AS13335
29	4	-	-

Security Scan Report: todaypoly.com

Summary

AI Security Verdict

Confirmed Scam

Risk Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies3

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History