@argonprotocol/testing 1.1.0-rc.2

package/lib/index.js

@@ -0,0 +1,625 @@
+// node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/index.ts
+import {
+  Keyring as Keyring3,
+  TxSubmitter as TxSubmitter2
+} from "@argonprotocol/mainchain";
+import { describe } from "vitest";
+import * as process4 from "node:process";
+import HttpProxy from "http-proxy";
+import * as child_process4 from "node:child_process";
+import * as http from "node:http";
+import * as url from "node:url";
+import * as Path5 from "node:path";
+
+// src/TestNotary.ts
+import { customAlphabet } from "nanoid";
+import pg from "pg";
+import * as child_process from "node:child_process";
+import {
+  Keyring,
+  TxSubmitter
+} from "@argonprotocol/mainchain";
+import * as fs from "node:fs";
+import * as readline from "node:readline";
+import * as process2 from "node:process";
+import * as Path from "node:path";
+var { Client: PgClient } = pg;
+var 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 Keyring({ type: "sr25519" }).createFromUri("//Bob");
+    this.registeredPublicKey = new 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 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
+import * as fs2 from "node:fs";
+import { execSync as execSync2, spawn as spawn2 } from "node:child_process";
+import * as Path2 from "node:path";
+import * as readline2 from "node:readline";
+import { detectPort } from "detect-port";
+import { customAlphabet as customAlphabet2 } from "nanoid";
+import Client from "bitcoin-core";
+import { getClient } from "@argonprotocol/mainchain";
+var nanoid2 = customAlphabet2("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 Client({
+      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 = spawn2(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 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 {
+        execSync2(`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 detectPort();
+      const path2 = execSync2(
+        Path2.join(projectRoot(), `target/debug/argon-testing-bitcoin`),
+        {
+          encoding: "utf8"
+        }
+      ).trim();
+      const tmpDir = fs2.mkdtempSync("/tmp/argon-bitcoin-" + this.uuid);
+      this.#bitcoind = spawn2(
+        path2,
+        [
+          "-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
+import * as child_process2 from "node:child_process";
+import * as Path3 from "node:path";
+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
+import * as child_process3 from "node:child_process";
+import { Keyring as Keyring2 } from "@argonprotocol/mainchain";
+import * as fs3 from "node:fs";
+import * as readline3 from "node:readline";
+import * as process3 from "node:process";
+import * as Path4 from "node:path";
+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 Keyring2({ 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 = describe;
+if (process4.env.SKIP_E2E === "true" || process4.env.SKIP_E2E === "1") {
+  describeIntegration = describe.skip;
+}
+async function getProxy() {
+  if (!proxy) {
+    proxy = HttpProxy.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 Keyring3({ type: "sr25519" }).createFromUri("//Alice");
+}
+async function activateNotary(sudo2, client, notary) {
+  await notary.register(client);
+  await new TxSubmitter2(
+    client,
+    client.tx.sudo.sudo(
+      client.tx.notaries.activate(notary.operator.publicKey)
+    ),
+    sudo2
+  ).submit({ waitForBlock: true });
+}
+export {
+  TestBitcoinCli,
+  TestMainchain,
+  TestNotary,
+  TestOracle,
+  activateNotary,
+  addTeardown,
+  cleanHostForDocker,
+  closeOnTeardown,
+  describeIntegration,
+  disconnectOnTeardown,
+  getDockerPortMapping,
+  getProxy,
+  projectRoot,
+  runTestScript,
+  sudo,
+  teardown
+};
+//# sourceMappingURL=index.js.map