@botsigged/sdk 1.0.0 → 1.0.2

package/dist/challenge-ng9p6s5y.js

@@ -0,0 +1,333 @@
+import {
+  getHash
+} from "./hash-gtpm69df.js";
+
+// src/challenge-ui.ts
+class ChallengeOverlay {
+  overlay = null;
+  messageEl = null;
+  progressEl = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  show() {
+    if (!this.config.enabled || this.overlay)
+      return;
+    this.overlay = document.createElement("div");
+    this.overlay.id = "botsigged-challenge-overlay";
+    this.overlay.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background: ${this.config.backgroundColor};
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      z-index: ${this.config.zIndex};
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    `;
+    const spinner = document.createElement("div");
+    spinner.style.cssText = `
+      width: 48px;
+      height: 48px;
+      border: 4px solid ${this.config.textColor}33;
+      border-top-color: ${this.config.spinnerColor};
+      border-radius: 50%;
+      animation: botsigged-spin 1s linear infinite;
+      margin-bottom: 20px;
+    `;
+    this.messageEl = document.createElement("span");
+    this.messageEl.textContent = this.config.message;
+    this.messageEl.style.cssText = `
+      color: ${this.config.textColor};
+      font-size: 18px;
+      font-weight: 500;
+      margin-bottom: 12px;
+    `;
+    const progressContainer = document.createElement("div");
+    progressContainer.style.cssText = `
+      width: 200px;
+      height: 4px;
+      background: ${this.config.textColor}33;
+      border-radius: 2px;
+      overflow: hidden;
+    `;
+    this.progressEl = document.createElement("div");
+    this.progressEl.style.cssText = `
+      width: 0%;
+      height: 100%;
+      background: ${this.config.spinnerColor};
+      border-radius: 2px;
+      transition: width 0.1s ease-out;
+    `;
+    progressContainer.appendChild(this.progressEl);
+    const style = document.createElement("style");
+    style.textContent = `
+      @keyframes botsigged-spin {
+        to { transform: rotate(360deg); }
+      }
+    `;
+    document.head.appendChild(style);
+    this.overlay.appendChild(spinner);
+    this.overlay.appendChild(this.messageEl);
+    this.overlay.appendChild(progressContainer);
+    document.body.appendChild(this.overlay);
+  }
+  setProgress(progress) {
+    if (this.progressEl) {
+      const percent = Math.min(100, Math.max(0, progress * 100));
+      this.progressEl.style.width = `${percent}%`;
+    }
+  }
+  showSuccess() {
+    if (this.messageEl) {
+      this.messageEl.textContent = this.config.successMessage;
+    }
+    if (this.progressEl) {
+      this.progressEl.style.width = "100%";
+    }
+  }
+  hide() {
+    if (this.overlay) {
+      this.overlay.remove();
+      this.overlay = null;
+      this.messageEl = null;
+      this.progressEl = null;
+    }
+  }
+  isVisible() {
+    return this.overlay !== null;
+  }
+}
+
+// src/challenge.ts
+function generateChallengePrefix() {
+  const prefix = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(prefix);
+  } else {
+    for (let i = 0;i < 16; i++) {
+      prefix[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return prefix;
+}
+function countLeadingZeroBits(value) {
+  if (value === 0)
+    return 32;
+  let count = 0;
+  if ((value & 4294901760) === 0) {
+    count += 16;
+    value <<= 16;
+  }
+  if ((value & 4278190080) === 0) {
+    count += 8;
+    value <<= 8;
+  }
+  if ((value & 4026531840) === 0) {
+    count += 4;
+    value <<= 4;
+  }
+  if ((value & 3221225472) === 0) {
+    count += 2;
+    value <<= 2;
+  }
+  if ((value & 2147483648) === 0) {
+    count += 1;
+  }
+  return count;
+}
+function solvePoWChunkJS(prefix, difficulty, chunkSize, startNonce) {
+  const hashModule = getHash();
+  const buffer = new Uint8Array(prefix.length + 4);
+  buffer.set(prefix);
+  let nonce = startNonce;
+  let iterations = 0;
+  while (iterations < chunkSize) {
+    buffer[prefix.length] = nonce & 255;
+    buffer[prefix.length + 1] = nonce >>> 8 & 255;
+    buffer[prefix.length + 2] = nonce >>> 16 & 255;
+    buffer[prefix.length + 3] = nonce >>> 24 & 255;
+    const hash = hashModule.xxHash32(buffer, 0);
+    iterations++;
+    if (countLeadingZeroBits(hash) >= difficulty) {
+      return { nonce, found: true, iterations };
+    }
+    nonce = nonce + 1 >>> 0;
+  }
+  return { nonce, found: false, iterations };
+}
+
+class ChallengeManager {
+  config;
+  overlay;
+  solving = false;
+  solved = false;
+  pendingForms = new Map;
+  formHandler = null;
+  formObserver = null;
+  resubmitting = false;
+  debug;
+  constructor(config, debug = false) {
+    this.config = config;
+    this.debug = debug;
+    this.overlay = new ChallengeOverlay(config.ui);
+  }
+  getDifficultyForLevel(level) {
+    const difficulty = this.config.difficulty;
+    switch (level) {
+      case "critical":
+        return difficulty.critical;
+      case "high":
+        return difficulty.high;
+      case "medium":
+        return difficulty.medium;
+      default:
+        return 0;
+    }
+  }
+  shouldChallenge(level) {
+    if (!this.config.enabled || this.solved)
+      return false;
+    const levelOrder = ["low", "medium", "high", "critical"];
+    const levelIndex = levelOrder.indexOf(level);
+    const minIndex = levelOrder.indexOf(this.config.minLevel);
+    return levelIndex >= minIndex;
+  }
+  blockFormsUntilSolved(level) {
+    if (this.formHandler)
+      return;
+    this.formHandler = (e) => {
+      if (this.solved || this.resubmitting)
+        return;
+      e.preventDefault();
+      e.stopPropagation();
+      const form = e.target;
+      if (!this.pendingForms.has(form)) {
+        this.pendingForms.set(form, e);
+      }
+      if (!this.solving) {
+        this.startChallenge(level);
+      }
+    };
+    document.querySelectorAll("form").forEach((form) => {
+      form.addEventListener("submit", this.formHandler, true);
+    });
+    this.formObserver = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node instanceof HTMLFormElement && this.formHandler) {
+            node.addEventListener("submit", this.formHandler, true);
+          }
+          if (node instanceof HTMLElement && this.formHandler) {
+            node.querySelectorAll("form").forEach((form) => {
+              form.addEventListener("submit", this.formHandler, true);
+            });
+          }
+        });
+      });
+    });
+    this.formObserver.observe(document.body, { childList: true, subtree: true });
+    this.log("Forms blocked, challenge required");
+  }
+  async startChallenge(level) {
+    if (this.solving || this.solved)
+      return;
+    this.solving = true;
+    const difficulty = this.getDifficultyForLevel(level);
+    const prefix = generateChallengePrefix();
+    const startTime = performance.now();
+    this.log(`Starting challenge: difficulty=${difficulty}, level=${level}`);
+    this.config.onChallengeStart?.(level, difficulty);
+    this.overlay.show();
+    const estimatedIterations = 1 << difficulty;
+    let nonce = 0;
+    let totalIterations = 0;
+    let result;
+    do {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      result = solvePoWChunkJS(prefix, difficulty, this.config.chunkSize, nonce);
+      totalIterations += result.iterations;
+      nonce = result.nonce + 1;
+      const progress = Math.min(1, totalIterations / estimatedIterations);
+      this.overlay.setProgress(progress);
+      this.config.onChallengeProgress?.(progress, totalIterations);
+    } while (!result.found);
+    const solveTime = performance.now() - startTime;
+    this.log(`Challenge solved: nonce=${result.nonce}, iterations=${totalIterations}, time=${solveTime.toFixed(0)}ms`);
+    this.overlay.showSuccess();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    this.overlay.hide();
+    this.solved = true;
+    this.solving = false;
+    const event = {
+      solveTimeMs: solveTime,
+      iterations: totalIterations,
+      difficulty,
+      level,
+      nonce: result.nonce
+    };
+    this.config.onChallengeComplete?.(event);
+    this.unblockForms();
+  }
+  unblockForms() {
+    if (this.formObserver) {
+      this.formObserver.disconnect();
+      this.formObserver = null;
+    }
+    if (this.formHandler) {
+      document.querySelectorAll("form").forEach((form) => {
+        form.removeEventListener("submit", this.formHandler, true);
+      });
+      this.formHandler = null;
+    }
+    this.log("Forms unblocked");
+    this.resubmitting = true;
+    this.pendingForms.forEach((_, form) => {
+      this.log("Resubmitting pending form");
+      if (form.requestSubmit) {
+        form.requestSubmit();
+      } else {
+        form.submit();
+      }
+    });
+    this.pendingForms.clear();
+    this.resubmitting = false;
+  }
+  isSolving() {
+    return this.solving;
+  }
+  isSolved() {
+    return this.solved;
+  }
+  reset() {
+    if (this.formObserver) {
+      this.formObserver.disconnect();
+      this.formObserver = null;
+    }
+    if (this.formHandler) {
+      document.querySelectorAll("form").forEach((form) => {
+        form.removeEventListener("submit", this.formHandler, true);
+      });
+      this.formHandler = null;
+    }
+    this.solved = false;
+    this.solving = false;
+    this.resubmitting = false;
+    this.pendingForms.clear();
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log("[BotSigged:Challenge]", ...args);
+    }
+  }
+}
+export {
+  ChallengeManager
+};
+
+//# debugId=B0255CA1E0DDDD3364756E2164756E21

package/dist/hash-gtpm69df.js

@@ -0,0 +1,300 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/wasm/hash.wasm.base64.ts
+var wasmBinaryBase64 = "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";
+var hash_wasm_base64_default = wasmBinaryBase64;
+
+// src/wasm/hash-wasm.ts
+var wasmInstance = null;
+var loadPromise = null;
+function base64ToBytes(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0;i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+async function loadHashModule() {
+  if (loadPromise) {
+    return loadPromise;
+  }
+  loadPromise = (async () => {
+    try {
+      const wasmBytes = base64ToBytes(hash_wasm_base64_default);
+      const wasmModule = await WebAssembly.compile(wasmBytes);
+      const instance = await WebAssembly.instantiate(wasmModule, {
+        env: {
+          abort: (_msg, _file, line, col) => {
+            console.error(`WASM abort at ${line}:${col}`);
+          }
+        }
+      });
+      wasmInstance = instance.exports;
+      return createHashModule(wasmInstance);
+    } catch (error) {
+      loadPromise = null;
+      throw error;
+    }
+  })();
+  return loadPromise;
+}
+function isHashModuleLoaded() {
+  return wasmInstance !== null;
+}
+function createHashModule(wasm) {
+  function writeBytes(data) {
+    const ptr = wasm.__new(data.length, 1);
+    const view = new Uint8Array(wasm.memory.buffer, ptr, data.length);
+    view.set(data);
+    return ptr;
+  }
+  function writeString(str) {
+    const buf = new Uint16Array(str.length);
+    for (let i = 0;i < str.length; i++) {
+      buf[i] = str.charCodeAt(i);
+    }
+    const ptr = wasm.__new(buf.length * 2, 2);
+    const mem = new Uint16Array(wasm.memory.buffer, ptr, buf.length);
+    mem.set(buf);
+    return ptr;
+  }
+  function readString(ptr, maxLength = 1024) {
+    const memory = new Uint8Array(wasm.memory.buffer);
+    const memoryLength = memory.length;
+    if (ptr < 0 || ptr >= memoryLength) {
+      return "";
+    }
+    let end = ptr;
+    const limit = Math.min(ptr + maxLength, memoryLength);
+    while (end < limit && memory[end] !== 0) {
+      end++;
+    }
+    const bytes = memory.slice(ptr, end);
+    return new TextDecoder().decode(bytes);
+  }
+  return {
+    xxHash32(data, seed = 0) {
+      const ptr = writeBytes(data);
+      try {
+        return wasm.xxHash32(ptr, seed);
+      } finally {
+        wasm.__unpin(ptr);
+      }
+    },
+    hashString(str, seed = 0) {
+      const ptr = writeString(str);
+      try {
+        return wasm.hashString(ptr, seed);
+      } finally {
+        wasm.__unpin(ptr);
+      }
+    },
+    hashStringToHex(str, seed = 0) {
+      const ptr = writeString(str);
+      try {
+        const resultPtr = wasm.hashStringToHex(ptr, seed);
+        return readString(resultPtr);
+      } finally {
+        wasm.__unpin(ptr);
+      }
+    },
+    verifyHash(data, expectedHash, seed = 0) {
+      const ptr = writeBytes(data);
+      try {
+        return wasm.verifyHash(ptr, expectedHash, seed);
+      } finally {
+        wasm.__unpin(ptr);
+      }
+    },
+    verifyStringHash(str, expectedHash, seed = 0) {
+      const ptr = writeString(str);
+      try {
+        return wasm.verifyStringHash(ptr, expectedHash, seed);
+      } finally {
+        wasm.__unpin(ptr);
+      }
+    }
+  };
+}
+function createFallbackHashModule() {
+  const textEncoder = new TextEncoder;
+  function xxHash32Impl(data, seed = 0) {
+    const PRIME32_1 = 2654435761;
+    const PRIME32_2 = 2246822519;
+    const PRIME32_3 = 3266489917;
+    const PRIME32_4 = 668265263;
+    const PRIME32_5 = 374761393;
+    const rotl32 = (x, r) => (x << r | x >>> 32 - r) >>> 0;
+    const readU32 = (arr, offset) => (arr[offset] | arr[offset + 1] << 8 | arr[offset + 2] << 16 | arr[offset + 3] << 24) >>> 0;
+    const len = data.length;
+    let h32;
+    let index = 0;
+    if (len >= 16) {
+      const limit = len - 16;
+      let v1 = seed + PRIME32_1 + PRIME32_2 >>> 0;
+      let v2 = seed + PRIME32_2 >>> 0;
+      let v3 = seed >>> 0;
+      let v4 = seed - PRIME32_1 >>> 0;
+      while (index <= limit) {
+        v1 = Math.imul(rotl32(v1 + Math.imul(readU32(data, index), PRIME32_2) >>> 0, 13), PRIME32_1) >>> 0;
+        index += 4;
+        v2 = Math.imul(rotl32(v2 + Math.imul(readU32(data, index), PRIME32_2) >>> 0, 13), PRIME32_1) >>> 0;
+        index += 4;
+        v3 = Math.imul(rotl32(v3 + Math.imul(readU32(data, index), PRIME32_2) >>> 0, 13), PRIME32_1) >>> 0;
+        index += 4;
+        v4 = Math.imul(rotl32(v4 + Math.imul(readU32(data, index), PRIME32_2) >>> 0, 13), PRIME32_1) >>> 0;
+        index += 4;
+      }
+      h32 = rotl32(v1, 1) + rotl32(v2, 7) + rotl32(v3, 12) + rotl32(v4, 18) >>> 0;
+    } else {
+      h32 = seed + PRIME32_5 >>> 0;
+    }
+    h32 = h32 + len >>> 0;
+    while (index <= len - 4) {
+      h32 = Math.imul(rotl32(h32 + Math.imul(readU32(data, index), PRIME32_3) >>> 0, 17), PRIME32_4) >>> 0;
+      index += 4;
+    }
+    while (index < len) {
+      h32 = Math.imul(rotl32(h32 + Math.imul(data[index], PRIME32_5) >>> 0, 11), PRIME32_1) >>> 0;
+      index++;
+    }
+    h32 ^= h32 >>> 15;
+    h32 = Math.imul(h32, PRIME32_2) >>> 0;
+    h32 ^= h32 >>> 13;
+    h32 = Math.imul(h32, PRIME32_3) >>> 0;
+    h32 ^= h32 >>> 16;
+    return h32 >>> 0;
+  }
+  function toHex(value) {
+    return (value >>> 0).toString(16).padStart(8, "0");
+  }
+  return {
+    xxHash32: xxHash32Impl,
+    hashString(str, seed = 0) {
+      return xxHash32Impl(textEncoder.encode(str), seed);
+    },
+    hashStringToHex(str, seed = 0) {
+      return toHex(xxHash32Impl(textEncoder.encode(str), seed));
+    },
+    verifyHash(data, expectedHash, seed = 0) {
+      return xxHash32Impl(data, seed) === expectedHash;
+    },
+    verifyStringHash(str, expectedHash, seed = 0) {
+      return xxHash32Impl(textEncoder.encode(str), seed) === expectedHash;
+    }
+  };
+}
+
+// src/hash.ts
+var hashModule = null;
+var initPromise = null;
+var useWasm = true;
+async function initHashModule(config = {}) {
+  const { preferWasm = true, onWasmLoaded, onFallback } = config;
+  if (hashModule) {
+    return hashModule;
+  }
+  if (initPromise) {
+    return initPromise;
+  }
+  initPromise = (async () => {
+    if (preferWasm) {
+      try {
+        hashModule = await loadHashModule();
+        useWasm = true;
+        onWasmLoaded?.();
+        return hashModule;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : "Unknown error";
+        onFallback?.(reason);
+      }
+    } else {
+      onFallback?.("WASM disabled by configuration");
+    }
+    hashModule = createFallbackHashModule();
+    useWasm = false;
+    return hashModule;
+  })();
+  return initPromise;
+}
+function getHash() {
+  if (hashModule) {
+    return hashModule;
+  }
+  hashModule = createFallbackHashModule();
+  useWasm = false;
+  return hashModule;
+}
+function isUsingWasm() {
+  return useWasm && isHashModuleLoaded();
+}
+function hash(data, seed = 0) {
+  const module = getHash();
+  if (typeof data === "string") {
+    return module.hashString(data, seed);
+  }
+  return module.xxHash32(data, seed);
+}
+function hashToHex(data, seed = 0) {
+  const module = getHash();
+  if (typeof data === "string") {
+    return module.hashStringToHex(data, seed);
+  }
+  return module.xxHash32(data, seed).toString(16).padStart(8, "0");
+}
+function verify(data, expectedHash, seed = 0) {
+  const module = getHash();
+  const expected = typeof expectedHash === "string" ? parseInt(expectedHash, 16) : expectedHash;
+  if (typeof data === "string") {
+    return module.verifyStringHash(data, expected, seed);
+  }
+  return module.verifyHash(data, expected, seed);
+}
+function createSignature(data, secret) {
+  const module = getHash();
+  const secretHash = module.hashString(secret, 0);
+  const dataHash = module.hashString(data, secretHash);
+  return dataHash.toString(16).padStart(8, "0");
+}
+function verifySignature(data, signature, secret) {
+  return createSignature(data, secret) === signature;
+}
+export {
+  verifySignature,
+  verify,
+  loadHashModule,
+  isUsingWasm,
+  isHashModuleLoaded,
+  initHashModule,
+  hashToHex,
+  hash,
+  getHash,
+  createSignature,
+  createFallbackHashModule
+};
+export { __toESM, __require, getHash, hashToHex };
+
+//# debugId=18EFA41CA1DEC13A64756E2164756E21