w3wallets 0.10.2 → 1.0.0-beta.10

package/dist/scripts/cache.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cache/buildCache.ts
+var import_path2 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
+var import_crypto2 = __toESM(require("crypto"));
+var import_test = require("@playwright/test");
+
+// src/cache/constants.ts
+var CACHE_DIR = ".w3wallets/cache";
+
+// src/cache/types.ts
+function isCachedConfig(config) {
+  return "__cached" in config && config.__cached === true;
+}
+
+// src/core/utils.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_crypto = __toESM(require("crypto"));
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getExtensionId(extensionPath) {
+  const absolutePath = import_path.default.resolve(extensionPath);
+  const manifestPath = import_path.default.join(absolutePath, "manifest.json");
+  const manifest = JSON.parse(import_fs.default.readFileSync(manifestPath, "utf-8"));
+  let dataToHash;
+  if (manifest.key) {
+    dataToHash = Buffer.from(manifest.key, "base64");
+  } else {
+    dataToHash = Buffer.from(absolutePath);
+  }
+  const hash = import_crypto.default.createHash("sha256").update(dataToHash).digest();
+  const ALPHABET = "abcdefghijklmnop";
+  let extensionId = "";
+  for (let i = 0; i < 16; i++) {
+    const byte = hash[i];
+    extensionId += ALPHABET[byte >> 4 & 15];
+    extensionId += ALPHABET[byte & 15];
+  }
+  return extensionId;
+}
+
+// src/timeouts.ts
+var SERVICE_WORKER_TIMEOUT = 3e4;
+var SERVICE_WORKER_POLL_INTERVAL = 500;
+var STORAGE_STABILIZE_TIMEOUT = 12e4;
+var STORAGE_POLL_INTERVAL = 5e3;
+var STORAGE_STABLE_CHECKS = 6;
+var HELPER_PAGE_TIMEOUT = 1e4;
+var LEVELDB_FLUSH_DELAY = 5e3;
+
+// src/debug.ts
+var isDebug = () => process.env.W3WALLETS_DEBUG === "true";
+function debug(message) {
+  if (!isDebug()) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  console.log(`[w3wallets ${ts}] ${message}`);
+}
+
+// src/cache/buildCache.ts
+var W3WALLETS_DIR = ".w3wallets";
+async function waitForStorageStable(helperPage, helperUrl) {
+  const TIMEOUT = STORAGE_STABILIZE_TIMEOUT;
+  const POLL_INTERVAL = STORAGE_POLL_INTERVAL;
+  const STABLE_CHECKS_REQUIRED = STORAGE_STABLE_CHECKS;
+  const start = Date.now();
+  let lastKeyCount = -1;
+  let stableCount = 0;
+  while (Date.now() - start < TIMEOUT) {
+    await sleep(POLL_INTERVAL);
+    await helperPage.goto(helperUrl);
+    await helperPage.waitForFunction(
+      () => document.title.startsWith("done:"),
+      null,
+      { timeout: HELPER_PAGE_TIMEOUT }
+    );
+    const title = await helperPage.title();
+    const keyCount = parseInt(title.split(":")[1], 10);
+    if (keyCount === 0) continue;
+    if (keyCount === lastKeyCount) {
+      stableCount++;
+    } else {
+      stableCount = 1;
+      lastKeyCount = keyCount;
+    }
+    debug(
+      `Storage poll: ${keyCount} keys (stable ${stableCount}/${STABLE_CHECKS_REQUIRED})`
+    );
+    if (stableCount >= STABLE_CHECKS_REQUIRED) {
+      console.log(`  Storage stabilized at ${keyCount} keys`);
+      return keyCount;
+    }
+    console.log(
+      `  Waiting for storage to stabilize: ${keyCount} keys (${stableCount}/${STABLE_CHECKS_REQUIRED})`
+    );
+  }
+  console.log(`  Storage stabilization timed out after ${TIMEOUT / 1e3}s`);
+  return null;
+}
+function hashFilePath(filePath) {
+  const hash = import_crypto2.default.createHash("sha256").update(filePath).digest("hex");
+  return hash.slice(0, 20);
+}
+async function buildCacheForSetup(compiledFilePath, originalFilePath, options2 = {}) {
+  const hash = hashFilePath(import_path2.default.resolve(originalFilePath));
+  const cacheDir = import_path2.default.join(process.cwd(), CACHE_DIR, hash);
+  if (!options2.force && import_fs2.default.existsSync(cacheDir)) {
+    console.log(`  Cache exists: ${cacheDir} (use --force to rebuild)`);
+    return;
+  }
+  const compiled = require(import_path2.default.resolve(compiledFilePath));
+  const config = compiled.default ?? compiled;
+  if (!isCachedConfig(config)) {
+    throw new Error(
+      `Setup file must export a CachedWalletConfig (use prepareWallet()): ${originalFilePath}`
+    );
+  }
+  const extPath = import_path2.default.join(process.cwd(), W3WALLETS_DIR, config.extensionDir);
+  if (!import_fs2.default.existsSync(import_path2.default.join(extPath, "manifest.json"))) {
+    throw new Error(
+      `Extension not found at ${extPath}. Run 'npx w3wallets ${config.name}' first.`
+    );
+  }
+  console.log(`  Building cache for "${config.name}"...`);
+  if (import_fs2.default.existsSync(cacheDir)) {
+    import_fs2.default.rmSync(cacheDir, { recursive: true });
+  }
+  const context = await import_test.chromium.launchPersistentContext(cacheDir, {
+    headless: !options2.headed,
+    channel: "chromium",
+    args: [
+      `--disable-extensions-except=${extPath}`,
+      `--load-extension=${extPath}`
+    ]
+  });
+  const extensionId = getExtensionId(extPath);
+  if (context.serviceWorkers().length < 1) {
+    await Promise.race([
+      context.waitForEvent("serviceworker", {
+        timeout: SERVICE_WORKER_TIMEOUT
+      }),
+      (async () => {
+        while (context.serviceWorkers().length < 1) {
+          await sleep(SERVICE_WORKER_POLL_INTERVAL);
+        }
+      })()
+    ]);
+  }
+  const page = await context.newPage();
+  const wallet = new config.WalletClass(page, extensionId);
+  await config.setupFn(wallet, page);
+  await page.goto(`chrome-extension://${extensionId}/home.html`);
+  await page.waitForLoadState("networkidle");
+  await page.goto(`chrome-extension://${extensionId}/home.html`);
+  await page.waitForLoadState("networkidle");
+  try {
+    const extDir = import_path2.default.join(process.cwd(), W3WALLETS_DIR, config.extensionDir);
+    const helperJs = import_path2.default.join(extDir, "_w3wallets_helper.js");
+    const helperHtml = import_path2.default.join(extDir, "_w3wallets_helper.html");
+    import_fs2.default.writeFileSync(
+      helperJs,
+      `chrome.storage.local.get(null, (data) => {
+        document.title = "done:" + Object.keys(data).length;
+      });`
+    );
+    import_fs2.default.writeFileSync(
+      helperHtml,
+      `<!DOCTYPE html><html><head><script src="_w3wallets_helper.js"></script></head><body></body></html>`
+    );
+    const helperPage = await context.newPage();
+    const helperUrl = `chrome-extension://${extensionId}/_w3wallets_helper.html`;
+    await waitForStorageStable(helperPage, helperUrl);
+    await helperPage.close();
+    import_fs2.default.unlinkSync(helperJs);
+    import_fs2.default.unlinkSync(helperHtml);
+  } catch (err) {
+    console.log(`  Note: could not verify persistence: ${err}`);
+  }
+  await sleep(LEVELDB_FLUSH_DELAY);
+  await context.close();
+  import_fs2.default.writeFileSync(
+    import_path2.default.join(cacheDir, ".meta.json"),
+    JSON.stringify({ name: config.name })
+  );
+  console.log(`  Cached: ${cacheDir}`);
+}
+async function buildAllCaches(directory, options2 = {}) {
+  const absoluteDir = import_path2.default.resolve(directory);
+  if (!import_fs2.default.existsSync(absoluteDir)) {
+    throw new Error(`Setup directory not found: ${absoluteDir}`);
+  }
+  const files = import_fs2.default.readdirSync(absoluteDir).filter((f) => {
+    return /\.cache\.(ts|js)$/.test(f);
+  });
+  if (files.length === 0) {
+    console.log(`No *.cache.{ts,js} files found in ${absoluteDir}`);
+    return;
+  }
+  console.log(`Found ${files.length} setup file(s) in ${absoluteDir}`);
+  const distDir = import_path2.default.join(process.cwd(), CACHE_DIR, ".dist");
+  const entryPoints = files.map((f) => import_path2.default.join(absoluteDir, f));
+  console.log("Compiling setup files...");
+  const { build } = await import("tsup");
+  await build({
+    entry: entryPoints,
+    outDir: distDir,
+    format: ["cjs"],
+    clean: true,
+    silent: true,
+    external: ["@playwright/test"]
+  });
+  let built = 0;
+  let skipped = 0;
+  for (const file of files) {
+    const baseName = file.replace(/\.ts$/, ".js");
+    const compiledPath = import_path2.default.join(distDir, baseName);
+    const originalPath = import_path2.default.join(absoluteDir, file);
+    console.log(`
+[${file}]`);
+    if (!import_fs2.default.existsSync(compiledPath)) {
+      console.log(`  Compiled file not found: ${compiledPath}`);
+      continue;
+    }
+    const hash = hashFilePath(import_path2.default.resolve(originalPath));
+    const cacheExists = import_fs2.default.existsSync(
+      import_path2.default.join(process.cwd(), CACHE_DIR, hash)
+    );
+    if (!options2.force && cacheExists) {
+      console.log(`  Cache exists (use --force to rebuild)`);
+      skipped++;
+      continue;
+    }
+    await buildCacheForSetup(compiledPath, originalPath, {
+      ...options2,
+      force: true
+    });
+    built++;
+  }
+  console.log(`
+Done: ${built} built, ${skipped} skipped`);
+}
+
+// src/scripts/cache.ts
+function parseArgs(args) {
+  const options2 = {
+    force: false,
+    headed: false,
+    directory: "./wallets-cache/"
+  };
+  for (const arg of args) {
+    if (arg === "-f" || arg === "--force") {
+      options2.force = true;
+    } else if (arg === "--headed") {
+      options2.headed = true;
+    } else if (arg === "-h" || arg === "--help") {
+      console.log(`
+w3wallets cache - Build wallet caches from setup files
+
+USAGE:
+  npx w3wallets cache [OPTIONS] [directory]
+
+ARGUMENTS:
+  directory       Directory containing *.cache.{ts,js} files (default: ./wallets-cache/)
+
+OPTIONS:
+  -f, --force     Force rebuild even if cache exists
+  --headed        Run browser in headed mode
+  -h, --help      Show this help message
+
+EXAMPLES:
+  npx w3wallets cache                        # Build caches from ./wallets-cache/
+  npx w3wallets cache ./tests/setups/        # Custom directory
+  npx w3wallets cache --force                # Force rebuild
+`);
+      process.exit(0);
+    } else if (!arg.startsWith("-")) {
+      options2.directory = arg;
+    } else {
+      console.error(`Error: Unknown option "${arg}"`);
+      process.exit(1);
+    }
+  }
+  return options2;
+}
+var options = parseArgs(process.argv.slice(2));
+buildAllCaches(options.directory, {
+  force: options.force,
+  headed: options.headed
+}).catch((err) => {
+  console.error(`Cache build failed: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "w3wallets",
   "description": "browser wallets for playwright",
-  "version": "0.10.2",
+  "version": "1.0.0-beta.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "homepage": "https://github.com/Maksandre/w3wallets",
@@ -16,12 +16,10 @@
   "keywords": [
     "e2e",
     "playwright",
-    "backpack",
     "metamask",
     "testing",
     "ethereum",
-    "polkadot",
-    "eclipse"
+    "polkadot"
   ],
   "license": "MIT",
   "publishConfig": {
@@ -32,32 +30,39 @@
   ],
   "bin": "./src/scripts/download.js",
   "scripts": {
-    "start:ui": "yarn workspace @w3wallets/test-app buildAndStart",
-    "download-wallets": "npx w3wallets backpack polkadotJS metamask",
-    "test": "npx playwright test --project=local --workers=2",
+    "download-wallets": "npx w3wallets pjs mm",
+    "cache-wallets": "npx w3wallets cache --force ./tests/wallets-cache/",
+    "test": "npx playwright test --project=local",
     "test:ci": "npx playwright test --project=ci",
     "build": "tsup",
     "clean": "rm -rf dist",
     "check-format": "prettier --check .",
     "check-exports": "attw --pack .",
     "format": "prettier --write .",
-    "lint": "tsc",
-    "ci": "yarn lint && yarn clean && yarn build && yarn check-format && yarn check-exports",
+    "lint": "tsc && eslint .",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "ci": "yarn test:unit && yarn lint && yarn clean && yarn build && yarn check-format && yarn check-exports",
     "changeset": "npx changeset",
     "local-release": "changeset version && changeset publish"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.2",
     "@changesets/cli": "^2.27.11",
-    "@playwright/test": "^1.50.1",
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "1.58.1",
     "@types/node": "^22.10.5",
     "dotenv": "^16.4.7",
+    "eslint": "^10.0.2",
+    "eslint-config-prettier": "^10.1.8",
     "prettier": "^3.4.2",
     "standard-version": "^9.5.0",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.56.1",
+    "vitest": "^3.0.0"
   },
   "peerDependencies": {
-    "@playwright/test": "^1.50.1"
+    "@playwright/test": "^1.57.0"
   }
 }