@argonprotocol/testing 1.1.0-rc.2

package/lib/index.cjs

@@ -0,0 +1,662 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TestBitcoinCli: () => TestBitcoinCli,
+  TestMainchain: () => TestMainchain,
+  TestNotary: () => TestNotary,
+  TestOracle: () => TestOracle,
+  activateNotary: () => activateNotary,
+  addTeardown: () => addTeardown,
+  cleanHostForDocker: () => cleanHostForDocker,
+  closeOnTeardown: () => closeOnTeardown,
+  describeIntegration: () => describeIntegration,
+  disconnectOnTeardown: () => disconnectOnTeardown,
+  getDockerPortMapping: () => getDockerPortMapping,
+  getProxy: () => getProxy,
+  projectRoot: () => projectRoot,
+  runTestScript: () => runTestScript,
+  sudo: () => sudo,
+  teardown: () => teardown
+});
+module.exports = __toCommonJS(index_exports);
+var import_mainchain4 = require("@argonprotocol/mainchain");
+var import_vitest = require("vitest");
+var process4 = __toESM(require("process"), 1);
+var import_http_proxy = __toESM(require("http-proxy"), 1);
+var child_process4 = __toESM(require("child_process"), 1);
+var http = __toESM(require("http"), 1);
+var url = __toESM(require("url"), 1);
+var Path5 = __toESM(require("path"), 1);
+
+// src/TestNotary.ts
+var import_nanoid = require("nanoid");
+var import_pg = __toESM(require("pg"), 1);
+var child_process = __toESM(require("child_process"), 1);
+var import_mainchain = require("@argonprotocol/mainchain");
+var fs = __toESM(require("fs"), 1);
+var readline = __toESM(require("readline"), 1);
+var process2 = __toESM(require("process"), 1);
+var Path = __toESM(require("path"), 1);
+var { Client: PgClient } = import_pg.default;
+var nanoid = (0, import_nanoid.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 4);
+function createUid() {
+  return nanoid();
+}
+var TestNotary = class {
+  operator;
+  ip = "127.0.0.1";
+  registeredPublicKey;
+  port;
+  containerName;
+  proxy;
+  #dbName;
+  #dbConnectionString;
+  #childProcess;
+  #stdioInterface;
+  get address() {
+    if (this.proxy) {
+      const url2 = new URL(this.proxy);
+      url2.searchParams.set("target", `ws://${this.ip}:${this.port}`);
+      return url2.href;
+    }
+    return `ws://${this.ip}:${this.port}`;
+  }
+  constructor(dbConnectionString) {
+    this.#dbConnectionString = dbConnectionString ?? process2.env.NOTARY_DB_URL ?? "postgres://postgres:postgres@localhost:5432";
+    addTeardown(this);
+  }
+  /**
+   * Returns the localhost address of the notary (NOTE: not accessible from containers)
+   */
+  async start(options) {
+    const { pathToNotaryBin, uuid, mainchainUrl } = options;
+    this.operator = new import_mainchain.Keyring({ type: "sr25519" }).createFromUri("//Bob");
+    this.registeredPublicKey = new import_mainchain.Keyring({ type: "ed25519" }).createFromUri(
+      "//Ferdie//notary"
+    ).publicKey;
+    let notaryPath = pathToNotaryBin ?? Path.join(projectRoot(), "target/debug/argon-notary");
+    if (process2.env.ARGON_USE_DOCKER_BINS) {
+      this.containerName = "notary_" + uuid;
+      const addHost = process2.env.ADD_DOCKER_HOST ? ` --add-host=host.docker.internal:host-gateway` : "";
+      notaryPath = `docker run --rm -p=0:9925${addHost} --name=${this.containerName} -e RUST_LOG=warn ghcr.io/argonprotocol/argon-notary:dev`;
+      this.#dbConnectionString = cleanHostForDocker(this.#dbConnectionString);
+    } else if (!fs.existsSync(notaryPath)) {
+      throw new Error(`Notary binary not found at ${notaryPath}`);
+    }
+    const client = await this.connect();
+    let dbName = "";
+    try {
+      let tries = 10;
+      while (tries > 0) {
+        dbName = `notary_${uuid}`;
+        const result2 = await client.query(
+          "SELECT 1 FROM pg_database WHERE datname = $1",
+          [dbName]
+        );
+        if (result2.rowCount === 0) {
+          break;
+        }
+        tries -= 1;
+      }
+      this.#dbName = dbName;
+      await client.query(`CREATE DATABASE "${dbName}"`);
+    } finally {
+      await client.end();
+    }
+    let result = child_process.execSync(
+      `${notaryPath} migrate --db-url ${this.#dbConnectionString}/${this.#dbName}`,
+      {
+        encoding: "utf-8"
+      }
+    );
+    if (result.trim().length) {
+      console.log(result.trim());
+    }
+    console.log(
+      "Notary >> connecting to mainchain '%s', db %s",
+      mainchainUrl,
+      `${this.#dbConnectionString}/${this.#dbName}`
+    );
+    const bucketName = `notary-${uuid}`;
+    const execArgs = [
+      "run",
+      `--db-url=${this.#dbConnectionString}/${this.#dbName}`,
+      `--dev`,
+      `-t ${mainchainUrl}`,
+      `--archive-bucket=${bucketName}`,
+      `--operator-address=${this.operator.address}`
+    ];
+    if (process2.env.ARGON_USE_DOCKER_BINS) {
+      process2.env.AWS_S3_ENDPOINT = "http://host.docker.internal:9000";
+      execArgs.unshift(...notaryPath.replace("docker run", "run").split(" "));
+      execArgs.push("-b=0.0.0.0:9925");
+      notaryPath = "docker";
+    }
+    if (process2.env.AWS_S3_ENDPOINT) {
+      execArgs.push(`--archive-endpoint=${process2.env.AWS_S3_ENDPOINT}`);
+    }
+    this.#childProcess = child_process.spawn(notaryPath, execArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process2.env, RUST_LOG: "warn" }
+    });
+    this.#childProcess.stdout.setEncoding("utf8");
+    this.#childProcess.stderr.setEncoding("utf8");
+    this.port = await new Promise((resolve3, reject) => {
+      const onProcessError = (err) => {
+        console.warn("Error running notary", err);
+        reject(err);
+      };
+      this.#childProcess.once("error", onProcessError);
+      this.#childProcess.stderr.on("data", (data) => {
+        console.warn("Notary >> %s", data);
+        if (data.startsWith("WARNING")) return;
+        this.#childProcess.off("error", onProcessError);
+        reject(data);
+      });
+      this.#stdioInterface = readline.createInterface({ input: this.#childProcess.stdout }).on("line", (line) => {
+        console.log("Notary >> %s", line);
+        let match = line.match(/Listening on ([ws:/\d.]+)/);
+        if (match?.length ?? 0 > 0) {
+          resolve3(match[1].split(":").pop());
+        }
+      });
+    });
+    this.#childProcess.on("error", (err) => {
+      throw err;
+    });
+    if (this.containerName) {
+      this.port = await getDockerPortMapping(this.containerName, 9925);
+      this.proxy = cleanHostForDocker(await getProxy());
+    }
+    return this.address;
+  }
+  async register(client) {
+    let address = new URL(this.address);
+    await new import_mainchain.TxSubmitter(
+      client,
+      client.tx.notaries.propose({
+        public: this.registeredPublicKey,
+        hosts: [address.href],
+        name: "Test Notary"
+      }),
+      this.operator
+    ).submit({ waitForBlock: true });
+  }
+  async teardown() {
+    this.#childProcess?.kill();
+    this.#stdioInterface?.close();
+    const client = await this.connect();
+    try {
+      await client.query(`DROP DATABASE "${this.#dbName}" WITH (FORCE)`);
+    } finally {
+      await client.end();
+    }
+    if (this.containerName) {
+      try {
+        child_process.execSync(`docker rm -f ${this.containerName}`);
+      } catch {
+      }
+    }
+  }
+  async connect() {
+    const client = new PgClient({ connectionString: this.#dbConnectionString });
+    try {
+      await client.connect();
+    } catch (err) {
+      console.error("ERROR connecting to postgres client", err);
+      throw err;
+    }
+    return client;
+  }
+};
+
+// src/TestMainchain.ts
+var fs2 = __toESM(require("fs"), 1);
+var import_node_child_process = require("child_process");
+var Path2 = __toESM(require("path"), 1);
+var readline2 = __toESM(require("readline"), 1);
+var import_detect_port = require("detect-port");
+var import_nanoid2 = require("nanoid");
+var import_bitcoin_core = __toESM(require("bitcoin-core"), 1);
+var import_mainchain2 = require("@argonprotocol/mainchain");
+var nanoid2 = (0, import_nanoid2.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 4);
+var TestMainchain = class {
+  ip = "127.0.0.1";
+  port;
+  loglevel = "warn";
+  uuid;
+  #binPath;
+  #process;
+  #interfaces = [];
+  containerName;
+  proxy;
+  #bitcoind;
+  bitcoinPort;
+  get address() {
+    if (this.proxy) {
+      const url2 = new URL(this.proxy);
+      url2.searchParams.set("target", `ws://${this.ip}:${this.port}`);
+      return url2.href;
+    }
+    return `ws://${this.ip}:${this.port}`;
+  }
+  constructor(binPath) {
+    this.#binPath = binPath ?? Path2.join(projectRoot(), `target/debug/argon-node`);
+    this.#binPath = Path2.resolve(this.#binPath);
+    if (!process.env.ARGON_USE_DOCKER_BINS && !fs2.existsSync(this.#binPath)) {
+      throw new Error(`Mainchain binary not found at ${this.#binPath}`);
+    }
+    this.uuid = createUid();
+    addTeardown(this);
+  }
+  getBitcoinClient() {
+    return new import_bitcoin_core.default({
+      username: "bitcoin",
+      password: "bitcoin",
+      host: `http://localhost:${this.bitcoinPort}`
+    });
+  }
+  /**
+   * Launch and return the localhost url. NOTE: this url will not work cross-docker. You need to use the containerAddress property
+   * @param options
+   * @param options.miningThreads - number of threads to use for mining
+   * @param options.bootnodes - bootnodes to use for the mainchain
+   */
+  async launch(options) {
+    const {
+      miningThreads = 2,
+      bootnodes,
+      author = "alice",
+      launchBitcoin = false
+    } = options ?? {};
+    let port = 0;
+    let rpcPort = 0;
+    let execArgs = [];
+    let containerName;
+    if (process.env.ARGON_USE_DOCKER_BINS) {
+      containerName = "miner_" + nanoid2();
+      this.containerName = containerName;
+      this.#binPath = "docker";
+      port = 33344;
+      rpcPort = 9944;
+      execArgs = [
+        "run",
+        "--rm",
+        `--name=${containerName}`,
+        `-p=0:${port}`,
+        `-p=0:${rpcPort}`,
+        "-e",
+        `RUST_LOG=${this.loglevel},sc_rpc_server=info`,
+        "ghcr.io/argonprotocol/argon-miner:dev"
+      ];
+      if (process.env.ADD_DOCKER_HOST) {
+        execArgs.splice(2, 0, `--add-host=host.docker.internal:host-gateway`);
+      }
+    }
+    const bitcoinRpcUrl = await this.startBitcoin(launchBitcoin);
+    execArgs.push(
+      "--dev",
+      "--validator",
+      `--${author}`,
+      `--compute-miners=${miningThreads}`,
+      `--port=${port}`,
+      `--rpc-port=${rpcPort}`,
+      "--rpc-external",
+      "--unsafe-rpc-external",
+      "--rpc-methods=unsafe",
+      `--bitcoin-rpc-url=${bitcoinRpcUrl}`,
+      `--notebook-archive-hosts=http://127.0.0.1:9000/${this.uuid}`
+    );
+    if (bootnodes) {
+      execArgs.push(`--bootnodes=${bootnodes}`);
+    }
+    this.#process = (0, import_node_child_process.spawn)(this.#binPath, execArgs, {
+      stdio: ["ignore", "pipe", "pipe", "ignore"],
+      env: { ...process.env, RUST_LOG: `${this.loglevel},sc_rpc_server=info` }
+    });
+    this.#process.stderr.setEncoding("utf8");
+    this.#process.stdout.setEncoding("utf8");
+    this.#process.stdout.on("data", (data) => {
+      console.log("Main >> %s", data);
+    });
+    const int1 = readline2.createInterface({ input: this.#process.stdout }).on("line", (line) => {
+      if (line) console.log("Main >> %s", line);
+    });
+    this.#interfaces.push(int1);
+    this.port = await new Promise((resolve3, reject) => {
+      this.#process.on("error", (err) => {
+        console.warn("Error running mainchain", err);
+        reject(err);
+      });
+      const int2 = readline2.createInterface({ input: this.#process.stderr }).on("line", (line) => {
+        console.log("Main >> %s", line);
+        let match = line.match(/Running JSON-RPC server: addr=([\d.:]+)/);
+        if (match) {
+          let ipv4 = match[1].split(",").at(0);
+          resolve3(ipv4.split(":").pop());
+        }
+      });
+      this.#interfaces.push(int2);
+    });
+    if (this.containerName) {
+      this.port = await getDockerPortMapping(this.containerName, rpcPort);
+      this.proxy = cleanHostForDocker(await getProxy());
+    }
+    console.log(`argon Node listening at ${this.address}`);
+    return this.address;
+  }
+  async client() {
+    const client = await (0, import_mainchain2.getClient)(this.address);
+    disconnectOnTeardown(client);
+    return client;
+  }
+  async bootAddress() {
+    const client = await this.client();
+    const bootAddress = await client.rpc.system.localListenAddresses();
+    for (const address of bootAddress) {
+      const addr = address.toString();
+      if (addr.includes("127.0.0.1")) {
+        return addr;
+      }
+    }
+    return void 0;
+  }
+  async teardown() {
+    if (process.env.ARGON_USE_DOCKER_BINS) {
+      try {
+        (0, import_node_child_process.execSync)(`docker rm -f ${this.containerName}`);
+      } catch {
+      }
+    }
+    const launchedProcess = this.#process;
+    if (launchedProcess) {
+      launchedProcess?.kill();
+      try {
+        launchedProcess.stdio.forEach((io) => io?.destroy());
+      } catch {
+      }
+      launchedProcess.unref();
+    }
+    this.#process?.kill();
+    this.#process?.unref();
+    this.#bitcoind?.kill();
+    this.#bitcoind?.unref();
+    for (const i of this.#interfaces) {
+      i.close();
+    }
+  }
+  async startBitcoin(launchBitcoin) {
+    let rpcPort = 14338;
+    if (launchBitcoin) {
+      rpcPort = await (0, import_detect_port.detectPort)();
+      const path = (0, import_node_child_process.execSync)(
+        Path2.join(projectRoot(), `target/debug/argon-testing-bitcoin`),
+        {
+          encoding: "utf8"
+        }
+      ).trim();
+      const tmpDir = fs2.mkdtempSync("/tmp/argon-bitcoin-" + this.uuid);
+      this.#bitcoind = (0, import_node_child_process.spawn)(
+        path,
+        [
+          "-regtest",
+          "-fallbackfee=0.0001",
+          "-listen=0",
+          `-datadir=${tmpDir}`,
+          "-blockfilterindex",
+          "-txindex",
+          `-rpcport=${rpcPort}`,
+          "-rpcuser=bitcoin",
+          "-rpcpassword=bitcoin"
+        ],
+        {
+          stdio: ["ignore", "inherit", "inherit", "ignore"]
+        }
+      );
+      addTeardown({
+        async teardown() {
+          await fs2.promises.rm(tmpDir, {
+            recursive: true,
+            force: true
+          });
+        }
+      });
+    }
+    this.bitcoinPort = rpcPort;
+    return cleanHostForDocker(`http://bitcoin:bitcoin@localhost:${rpcPort}`);
+  }
+};
+
+// src/TestBitcoinCli.ts
+var child_process2 = __toESM(require("child_process"), 1);
+var Path3 = __toESM(require("path"), 1);
+var TestBitcoinCli = class {
+  /**
+   * Returns the localhost address of the notary (NOTE: not accessible from containers)
+   */
+  static run(command) {
+    const binPath = Path3.join(
+      `${projectRoot()}`,
+      "target/debug/argon-bitcoin-cli"
+    );
+    try {
+      return child_process2.execSync(`${binPath} ${command}`, {
+        encoding: "utf8"
+      }).trim();
+    } catch (e) {
+      console.error(`Error running command: ${command}`);
+      console.error(e.stdout);
+      throw e;
+    }
+  }
+};
+
+// src/TestOracle.ts
+var child_process3 = __toESM(require("child_process"), 1);
+var import_mainchain3 = require("@argonprotocol/mainchain");
+var fs3 = __toESM(require("fs"), 1);
+var readline3 = __toESM(require("readline"), 1);
+var process3 = __toESM(require("process"), 1);
+var Path4 = __toESM(require("path"), 1);
+var TestOracle = class _TestOracle {
+  static BitcoinOperator = "//Dave";
+  static PriceIndexOperator = "//Eve";
+  operator;
+  port;
+  #childProcess;
+  #stdioInterface;
+  constructor() {
+    addTeardown(this);
+  }
+  async start(service, options) {
+    const { pathToBin, mainchainUrl, bitcoinRpcUrl } = options;
+    const operatorSuri = service == "bitcoin" ? _TestOracle.BitcoinOperator : _TestOracle.PriceIndexOperator;
+    this.operator = new import_mainchain3.Keyring({ type: "sr25519" }).createFromUri(
+      operatorSuri
+    );
+    const binPath = pathToBin ?? Path4.join(projectRoot(), "target/debug/argon-oracle");
+    if (!fs3.existsSync(binPath)) {
+      throw new Error(`Oracle binary not found at ${binPath}`);
+    }
+    console.log(`Starting ${service} oracle`);
+    const execArgs = ["--dev", "-t", mainchainUrl, service];
+    if (service == "bitcoin") {
+      if (!bitcoinRpcUrl) {
+        throw new Error("Bitcoin RPC URL is required for bitcoin oracle");
+      }
+      execArgs.push("--bitcoin-rpc-url", bitcoinRpcUrl);
+    } else {
+      execArgs.push("--simulate-prices");
+    }
+    this.#childProcess = child_process3.spawn(binPath, execArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process3.env, RUST_LOG: "info", ...options.env }
+    });
+    this.#childProcess.stdout.setEncoding("utf8");
+    this.#childProcess.stderr.setEncoding("utf8");
+    this.#childProcess.stderr.on("data", (data) => {
+      console.warn("%sOracle >> %s", service, data);
+    });
+    this.#stdioInterface = readline3.createInterface({ input: this.#childProcess.stdout }).on("line", (line) => {
+      console.log("%sOracle >> %s", service, line);
+    });
+    this.#childProcess.on("error", (err) => {
+      throw err;
+    });
+  }
+  async teardown() {
+    this.#childProcess?.kill();
+    this.#stdioInterface?.close();
+  }
+};
+
+// src/index.ts
+var toTeardown = [];
+var proxy = null;
+var proxyServer = null;
+var describeIntegration = import_vitest.describe;
+if (process4.env.SKIP_E2E === "true" || process4.env.SKIP_E2E === "1") {
+  describeIntegration = import_vitest.describe.skip;
+}
+async function getProxy() {
+  if (!proxy) {
+    proxy = import_http_proxy.default.createProxyServer({
+      changeOrigin: true,
+      ws: true,
+      autoRewrite: true
+    });
+    proxy.on("error", () => null);
+    proxyServer = http.createServer(function(req, res) {
+      const queryData = url.parse(req.url, true).query;
+      if (!queryData.target) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("Target parameter is required");
+        return;
+      }
+      console.log("Proxying http request", queryData.target);
+      proxy?.web(req, res, { target: queryData.target });
+    });
+    proxyServer.on("upgrade", function(req, clientSocket, head) {
+      const queryData = url.parse(req.url, true).query;
+      const target = url.parse(queryData.target);
+      proxy?.ws(req, clientSocket, head, {
+        target: target.href,
+        ws: true
+      });
+      clientSocket.on("error", console.error);
+    });
+    await new Promise((resolve3) => proxyServer.listen(0, resolve3));
+    toTeardown.push({
+      teardown: () => new Promise((resolve3) => {
+        proxy?.close();
+        proxyServer?.close((_) => null);
+        proxy = null;
+        proxyServer = null;
+        resolve3();
+      })
+    });
+  }
+  const port = proxyServer.address().port;
+  return `ws://host.docker.internal:${port}`;
+}
+function projectRoot() {
+  if (process4.env.ARGON_PROJECT_ROOT) {
+    return Path5.join(process4.env.ARGON_PROJECT_ROOT);
+  }
+  return Path5.join(__dirname, `../../..`);
+}
+async function runTestScript(relativePath) {
+  const scriptPath = Path5.resolve(projectRoot(), relativePath);
+  return child_process4.execSync(scriptPath, { encoding: "utf8" }).trim();
+}
+async function getDockerPortMapping(containerName, port) {
+  return child_process4.execSync(`docker port ${containerName} ${port}`, { encoding: "utf8" }).trim().split(":").pop();
+}
+async function teardown() {
+  for (const t of toTeardown) {
+    try {
+      await t.teardown().catch(console.error);
+    } catch {
+    }
+  }
+  toTeardown.length = 0;
+}
+function cleanHostForDocker(host, replacer = "host.docker.internal") {
+  if (process4.env.ARGON_USE_DOCKER_BINS) {
+    return host.replace("localhost", replacer).replace("127.0.0.1", replacer).replace("0.0.0.0", replacer);
+  }
+  return host;
+}
+function addTeardown(teardownable) {
+  toTeardown.push(teardownable);
+}
+function closeOnTeardown(closeable) {
+  addTeardown({ teardown: () => closeable.close() });
+  return closeable;
+}
+function disconnectOnTeardown(closeable) {
+  addTeardown({ teardown: () => closeable.disconnect() });
+  return closeable;
+}
+function sudo() {
+  return new import_mainchain4.Keyring({ type: "sr25519" }).createFromUri("//Alice");
+}
+async function activateNotary(sudo2, client, notary) {
+  await notary.register(client);
+  await new import_mainchain4.TxSubmitter(
+    client,
+    client.tx.sudo.sudo(
+      client.tx.notaries.activate(notary.operator.publicKey)
+    ),
+    sudo2
+  ).submit({ waitForBlock: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestBitcoinCli,
+  TestMainchain,
+  TestNotary,
+  TestOracle,
+  activateNotary,
+  addTeardown,
+  cleanHostForDocker,
+  closeOnTeardown,
+  describeIntegration,
+  disconnectOnTeardown,
+  getDockerPortMapping,
+  getProxy,
+  projectRoot,
+  runTestScript,
+  sudo,
+  teardown
+});
+//# sourceMappingURL=index.cjs.map