@argonprotocol/testing 1.4.3-dev.8dfc7f36 → 1.4.3-dev.8e7d7af7

package/lib/index.js

@@ -10,9 +10,9 @@ import { Keyring as Keyring3, TxSubmitter as TxSubmitter2 } from "@argonprotocol
 import * as process4 from "process";
 import HttpProxy from "http-proxy";
 import * as child_process4 from "child_process";
-import * as http from "http";
+import * as http2 from "http";
 import * as url from "url";
-import * as Path6 from "path";
+import * as Path7 from "path";
 
 // src/TestNotary.ts
 import { customAlphabet } from "nanoid";
@@ -201,7 +201,6 @@ import * as Path2 from "path";
 import * as readline2 from "readline";
 import { detectPort } from "detect-port";
 import { customAlphabet as customAlphabet2 } from "nanoid";
-import Client from "bitcoin-core";
 import * as lockfile from "proper-lockfile";
 import { getClient } from "@argonprotocol/mainchain";
 var nanoid2 = customAlphabet2("0123456789abcdefghijklmnopqrstuvwxyz", 4);
@@ -237,11 +236,7 @@ var TestMainchain = class {
     addTeardown(this);
   }
   getBitcoinClient() {
-    return new Client({
-      username: "bitcoin",
-      password: "bitcoin",
-      host: `http://localhost:${this.bitcoinPort}`
-    });
+    return new BitcoinRpcClient(`http://localhost:${this.bitcoinPort}`, "bitcoin", "bitcoin");
   }
   /**
    * Launch and return the localhost url. NOTE: this url will not work cross-docker. You need to use the containerAddress property
@@ -331,9 +326,20 @@ var TestMainchain = class {
     return this.address;
   }
   async client() {
-    const client = await getClient(this.address);
-    disconnectOnTeardown(client);
-    return client;
+    let lastError;
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      try {
+        const client = await getClient(this.address);
+        disconnectOnTeardown(client);
+        return client;
+      } catch (error) {
+        lastError = error;
+        await new Promise((resolve3) => setTimeout(resolve3, 250));
+      }
+    }
+    throw new Error(`Unable to connect to mainchain client at ${this.address}`, {
+      cause: lastError instanceof Error ? lastError : void 0
+    });
   }
   async bootAddress() {
     const client = await this.client();
@@ -424,6 +430,51 @@ var TestMainchain = class {
     return cleanHostForDocker(`http://bitcoin:bitcoin@localhost:${rpcPort}`);
   }
 };
+var BitcoinRpcClient = class {
+  #rpcUrl;
+  #authorization;
+  constructor(rpcUrl, username, password) {
+    this.#rpcUrl = rpcUrl;
+    this.#authorization = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+  }
+  async command(method, ...params) {
+    const response = await fetch(this.#rpcUrl, {
+      method: "POST",
+      headers: {
+        authorization: this.#authorization,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "1.0",
+        id: `${method}-${Date.now()}`,
+        method,
+        params
+      })
+    });
+    const body = await response.text();
+    let payload;
+    if (body) {
+      try {
+        payload = JSON.parse(body);
+      } catch {
+        payload = void 0;
+      }
+    }
+    if (payload?.error) {
+      const httpStatus = response.ok ? "" : ` with HTTP ${response.status}`;
+      throw new Error(
+        `Bitcoin RPC ${method} failed${httpStatus} (${payload.error.code}): ${payload.error.message}`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(`Bitcoin RPC ${method} failed with HTTP ${response.status}`);
+    }
+    if (!payload) {
+      throw new Error(`Bitcoin RPC ${method} returned an invalid JSON response`);
+    }
+    return payload.result;
+  }
+};
 
 // src/TestBitcoinCli.ts
 import * as child_process2 from "child_process";
@@ -501,11 +552,459 @@ var TestOracle = class _TestOracle {
   }
 };
 
+// src/TestEthereum.ts
+import * as fs4 from "fs/promises";
+import * as os from "os";
+import * as Path5 from "path";
+import { spawn as spawn4, spawnSync } from "child_process";
+import { detectPort as detectPort2 } from "detect-port";
+
+// src/ethereumContracts.ts
+import { readFileSync } from "fs";
+function loadArtifact(fileName) {
+  return JSON.parse(
+    readFileSync(new URL(`./ethereum-contracts/${fileName}`, import.meta.url), "utf8")
+  );
+}
+var argonTokenArtifact = loadArtifact("ArgonToken.json");
+var argonotTokenArtifact = loadArtifact("ArgonotToken.json");
+var mintingGatewayArtifact = loadArtifact("MintingGateway.json");
+var proxyAdminArtifact = loadArtifact("ProxyAdmin.json");
+var transparentUpgradeableProxyArtifact = loadArtifact("TransparentUpgradeableProxy.json");
+
+// src/TestEthereum.ts
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  createPublicClient,
+  createWalletClient,
+  defineChain,
+  encodeFunctionData,
+  getAddress,
+  http,
+  zeroAddress
+} from "viem";
+var DEFAULT_KURTOSIS_BIN = "kurtosis";
+var DEFAULT_ETHEREUM_PACKAGE = "github.com/ethpandaops/ethereum-package";
+var DEFAULT_EL_PORT_START = 32e3;
+var DEFAULT_CL_PORT_START = 33e3;
+var PORT_RANGE_SIZE = 32;
+var ENCLAVE_NAME_PREFIX = "argon-eth-";
+var PROBE_INTERVAL_MS = 1e3;
+var PROBE_TIMEOUT_MS = 6e4;
+var LIGHT_CLIENT_READY_TIMEOUT_MS = 5 * 6e4;
+var KURTOSIS_RUN_TIMEOUT_MS = 20 * 6e4;
+var DEFAULT_SEED_ARGON_AMOUNT_BASE_UNITS = 1000000000n;
+var ERC1967_ADMIN_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
+var TestEthereum = class {
+  enclaveName;
+  kurtosisBin;
+  packageRef;
+  executionRpcUrl;
+  beaconApiUrl;
+  chainId;
+  #argsDir;
+  constructor(enclaveName = `${ENCLAVE_NAME_PREFIX}${Math.random().toString(36).slice(2, 8)}`, kurtosisBin = DEFAULT_KURTOSIS_BIN, packageRef = DEFAULT_ETHEREUM_PACKAGE) {
+    this.enclaveName = enclaveName;
+    this.kurtosisBin = kurtosisBin;
+    this.packageRef = packageRef;
+    addTeardown(this);
+  }
+  static isInstalled(kurtosisBin = DEFAULT_KURTOSIS_BIN) {
+    return spawnSync(kurtosisBin, ["version"], { stdio: "ignore" }).status === 0;
+  }
+  async launch(options) {
+    const {
+      consensusClient = "lighthouse",
+      preset = "mainnet",
+      secondsPerSlot,
+      waitForFinalization = true,
+      prefundedAccounts
+    } = options ?? {};
+    const elPublicPortStart = await findFreePortRange(DEFAULT_EL_PORT_START, PORT_RANGE_SIZE);
+    const clPublicPortStart = await findFreePortRange(DEFAULT_CL_PORT_START, PORT_RANGE_SIZE);
+    this.#argsDir = await fs4.mkdtemp(Path5.join(os.tmpdir(), "argon-ethereum-devnet-"));
+    const argsFile = Path5.join(this.#argsDir, "network-params.yaml");
+    await fs4.writeFile(
+      argsFile,
+      renderEthereumArgs(
+        elPublicPortStart,
+        clPublicPortStart,
+        consensusClient,
+        preset,
+        secondsPerSlot,
+        waitForFinalization,
+        prefundedAccounts
+      )
+    );
+    await runCommand(
+      this.kurtosisBin,
+      ["run", "--enclave", this.enclaveName, this.packageRef, "--args-file", argsFile],
+      KURTOSIS_RUN_TIMEOUT_MS
+    );
+    const executionRpc = await waitForProbe(
+      () => findExecutionRpcUrl(elPublicPortStart, PORT_RANGE_SIZE),
+      PROBE_TIMEOUT_MS
+    );
+    const beaconApi = await waitForProbe(
+      () => findBeaconApiUrl(clPublicPortStart, PORT_RANGE_SIZE),
+      PROBE_TIMEOUT_MS
+    );
+    this.executionRpcUrl = executionRpc.url;
+    this.beaconApiUrl = beaconApi.url;
+    this.chainId = executionRpc.chainId;
+    await waitForProbe(
+      () => this.getBeacon("/eth/v1/beacon/genesis"),
+      LIGHT_CLIENT_READY_TIMEOUT_MS
+    );
+    return {
+      executionRpcUrl: this.executionRpcUrl,
+      beaconApiUrl: this.beaconApiUrl,
+      chainId: this.chainId
+    };
+  }
+  async callExecution(method, params = []) {
+    const executionRpcUrl = this.executionRpcUrl;
+    if (!executionRpcUrl) {
+      throw new Error("Execution RPC URL is not available before launch");
+    }
+    const response = await fetch(executionRpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method,
+        params
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Execution RPC request failed for ${method}: ${response.status}`);
+    }
+    const body = await response.json();
+    if (body.error) {
+      throw new Error(
+        `Execution RPC ${method} failed (${body.error.code ?? "unknown"}): ${body.error.message ?? "unknown error"}`
+      );
+    }
+    return body.result;
+  }
+  async getBeacon(path2) {
+    const beaconApiUrl = this.beaconApiUrl;
+    if (!beaconApiUrl) {
+      throw new Error("Beacon API URL is not available before launch");
+    }
+    const response = await fetch(new URL(path2, `${beaconApiUrl}/`), {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Beacon API request failed for ${path2}: ${response.status}`);
+    }
+    return await response.json();
+  }
+  async deployMintingGatewayFixture(options) {
+    const { executionRpcUrl, chainId } = this;
+    if (!executionRpcUrl || !chainId) {
+      throw new Error("Ethereum devnet must be launched before deploying MintingGateway fixtures");
+    }
+    const account = privateKeyToAccount(options.deployerPrivateKey);
+    const adminSafe = options.adminSafe ?? account.address;
+    const guardianSafe = options.guardianSafe ?? adminSafe;
+    const chain = createExecutionChain(chainId, executionRpcUrl);
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(executionRpcUrl)
+    });
+    const walletClient = createWalletClient({
+      account,
+      chain,
+      transport: http(executionRpcUrl)
+    });
+    const bootstrapImplementationAddress = await deployContract(walletClient, publicClient, {
+      abi: mintingGatewayArtifact.abi,
+      bytecode: mintingGatewayArtifact.bytecode,
+      args: [zeroAddress, zeroAddress]
+    });
+    const initializeData = encodeFunctionData({
+      abi: mintingGatewayArtifact.abi,
+      functionName: "initialize",
+      args: [adminSafe, guardianSafe]
+    });
+    const gatewayAddress = await deployContract(walletClient, publicClient, {
+      abi: transparentUpgradeableProxyArtifact.abi,
+      bytecode: transparentUpgradeableProxyArtifact.bytecode,
+      args: [bootstrapImplementationAddress, adminSafe, initializeData]
+    });
+    const proxyAdminAddress = getAddressFromStorage(
+      await publicClient.getStorageAt({
+        address: gatewayAddress,
+        slot: ERC1967_ADMIN_SLOT
+      })
+    );
+    const argonTokenAddress = await deployContract(walletClient, publicClient, {
+      abi: argonTokenArtifact.abi,
+      bytecode: argonTokenArtifact.bytecode,
+      args: [gatewayAddress]
+    });
+    const argonotTokenAddress = await deployContract(walletClient, publicClient, {
+      abi: argonotTokenArtifact.abi,
+      bytecode: argonotTokenArtifact.bytecode,
+      args: [gatewayAddress]
+    });
+    const finalImplementationAddress = await deployContract(walletClient, publicClient, {
+      abi: mintingGatewayArtifact.abi,
+      bytecode: mintingGatewayArtifact.bytecode,
+      args: [argonTokenAddress, argonotTokenAddress]
+    });
+    const upgradeHash = await walletClient.sendTransaction({
+      to: proxyAdminAddress,
+      data: encodeFunctionData({
+        abi: proxyAdminArtifact.abi,
+        functionName: "upgradeAndCall",
+        args: [gatewayAddress, finalImplementationAddress, "0x"]
+      })
+    });
+    const upgradeReceipt = await waitForExecutionReceipt(publicClient, upgradeHash);
+    if (upgradeReceipt.status !== "success") {
+      throw new Error("MintingGateway proxy upgrade failed");
+    }
+    if (options.seedArgonRecipient) {
+      const mintHash = await walletClient.sendTransaction({
+        to: gatewayAddress,
+        data: encodeFunctionData({
+          abi: mintingGatewayArtifact.abi,
+          functionName: "adminMintBatch",
+          args: [
+            argonTokenAddress,
+            [options.seedArgonRecipient],
+            [options.seedArgonAmountBaseUnits ?? DEFAULT_SEED_ARGON_AMOUNT_BASE_UNITS]
+          ]
+        })
+      });
+      const mintReceipt = await waitForExecutionReceipt(publicClient, mintHash);
+      if (mintReceipt.status !== "success") {
+        throw new Error("MintingGateway admin mint failed");
+      }
+    }
+    return {
+      argonTokenAddress,
+      argonotTokenAddress,
+      gatewayAddress
+    };
+  }
+  async teardown() {
+    if (this.#argsDir) {
+      await fs4.rm(this.#argsDir, { recursive: true, force: true });
+      this.#argsDir = void 0;
+    }
+    await runCommand(this.kurtosisBin, ["enclave", "rm", "-f", this.enclaveName], 6e4, true);
+  }
+};
+async function deployContract(walletClient, publicClient, request) {
+  const hash = await walletClient.deployContract({
+    ...request,
+    account: walletClient.account,
+    chain: walletClient.chain
+  });
+  const receipt = await waitForExecutionReceipt(publicClient, hash);
+  if (receipt.status !== "success" || !receipt.contractAddress) {
+    throw new Error(`Contract deployment failed for ${request.bytecode.slice(0, 10)}`);
+  }
+  return receipt.contractAddress;
+}
+function getAddressFromStorage(value) {
+  if (!value || value === "0x") {
+    throw new Error("Missing proxy admin address in ERC1967 admin slot");
+  }
+  return getAddress(`0x${value.slice(-40)}`);
+}
+function renderEthereumArgs(elPublicPortStart, clPublicPortStart, consensusClient, preset, secondsPerSlot, waitForFinalization, prefundedAccounts) {
+  const lines = [
+    "participants:",
+    "  - el_type: geth",
+    `    cl_type: ${consensusClient}`,
+    "network_params:",
+    "  network: kurtosis",
+    `  preset: ${preset}`,
+    ...secondsPerSlot ? [`  seconds_per_slot: ${secondsPerSlot}`] : [],
+    ...prefundedAccounts && Object.keys(prefundedAccounts).length > 0 ? [`  prefunded_accounts: '${JSON.stringify(prefundedAccounts)}'`] : [],
+    "additional_services: []",
+    `wait_for_finalization: ${waitForFinalization ? "true" : "false"}`,
+    "global_log_level: warn",
+    "port_publisher:",
+    "  el:",
+    "    enabled: true",
+    `    public_port_start: ${elPublicPortStart}`,
+    "  cl:",
+    "    enabled: true",
+    `    public_port_start: ${clPublicPortStart}`
+  ];
+  lines.push("");
+  return lines.join("\n");
+}
+async function findExecutionRpcUrl(portStart, rangeSize) {
+  for (let port2 = portStart; port2 < portStart + rangeSize; port2 += 1) {
+    const url2 = `http://127.0.0.1:${port2}`;
+    const response = await fetchJsonRpc(url2, "eth_chainId");
+    if (typeof response === "string") {
+      return { url: url2, chainId: response };
+    }
+  }
+  throw new Error(
+    `Unable to find an execution RPC endpoint in ${portStart}-${portStart + rangeSize - 1}`
+  );
+}
+async function findBeaconApiUrl(portStart, rangeSize) {
+  for (let port2 = portStart; port2 < portStart + rangeSize; port2 += 1) {
+    const url2 = `http://127.0.0.1:${port2}`;
+    try {
+      const response = await fetch(new URL("/eth/v1/node/version", `${url2}/`), {
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (!response.ok) {
+        continue;
+      }
+      const body = await response.json();
+      if (body.data?.version) {
+        return { url: url2 };
+      }
+    } catch {
+    }
+  }
+  throw new Error(
+    `Unable to find a Beacon API endpoint in ${portStart}-${portStart + rangeSize - 1}`
+  );
+}
+async function fetchJsonRpc(url2, method) {
+  try {
+    const response = await fetch(url2, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method,
+        params: []
+      }),
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const body = await response.json();
+    return body.result ?? null;
+  } catch {
+    return null;
+  }
+}
+function createExecutionChain(chainId, executionRpcUrl) {
+  return defineChain({
+    id: Number.parseInt(chainId, 16),
+    name: "argon-test-ethereum",
+    nativeCurrency: {
+      name: "Ether",
+      symbol: "ETH",
+      decimals: 18
+    },
+    rpcUrls: {
+      default: {
+        http: [executionRpcUrl]
+      }
+    }
+  });
+}
+async function findFreePortRange(start, size) {
+  for (let candidate = start; candidate < start + 1e3; candidate += size) {
+    const ports = Array.from({ length: size }, (_, index) => candidate + index);
+    const results = await Promise.all(ports.map((port2) => detectPort2(port2)));
+    if (results.every((resolvedPort, index) => resolvedPort === ports[index])) {
+      return candidate;
+    }
+  }
+  throw new Error(`Unable to find a free port range starting near ${start}`);
+}
+async function waitForProbe(probe, timeoutMs) {
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      return await probe();
+    } catch (error) {
+      lastError = error;
+      await delay(PROBE_INTERVAL_MS);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Timed out waiting for probe");
+}
+async function waitForExecutionReceipt(publicClient, hash) {
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < 12e4) {
+    try {
+      const receipt = await publicClient.getTransactionReceipt({ hash });
+      if (receipt) {
+        return receipt;
+      }
+    } catch (error) {
+      const errorText = error instanceof Error ? [
+        error.message,
+        "details" in error && typeof error.details === "string" ? error.details : void 0
+      ].filter(Boolean).join(" ") : String(error);
+      if (!errorText.includes("indexing is in progress") && !errorText.includes("Transaction receipt with hash") && !errorText.includes("could not be found")) {
+        throw error;
+      }
+      lastError = error instanceof Error ? error : new Error(errorText);
+    }
+    await delay(500);
+  }
+  throw lastError ?? new Error(`Timed out waiting for execution receipt ${hash}`);
+}
+async function runCommand(command, args, timeoutMs, allowFailure = false) {
+  await new Promise((resolve3, reject) => {
+    const child = spawn4(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`Command timed out: ${command} ${args.join(" ")}`));
+    }, timeoutMs);
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timeout);
+      if (code === 0 || allowFailure) {
+        resolve3();
+        return;
+      }
+      reject(
+        new Error(
+          [`Command failed: ${command} ${args.join(" ")}`, stdout.trim(), stderr.trim()].filter(Boolean).join("\n")
+        )
+      );
+    });
+  });
+}
+async function delay(ms) {
+  await new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
 // src/TestNetwork.ts
 import * as docker from "docker-compose";
-import * as Path5 from "path";
+import * as Path6 from "path";
 async function startNetwork(testName, options) {
-  const config = Path5.join(__dirname, `docker-compose.yml`);
+  const config = Path6.join(__dirname, `dev.docker-compose.yml`);
   const env4 = {
     VERSION: "dev",
     ARGON_CHAIN: "dev-docker",
@@ -550,7 +1049,7 @@ async function getProxy() {
       autoRewrite: true
     });
     proxy.on("error", () => null);
-    proxyServer = http.createServer(function(req, res) {
+    proxyServer = http2.createServer(function(req, res) {
       const queryData = url.parse(req.url, true).query;
       if (!queryData.target) {
         res.writeHead(500, { "Content-Type": "text/plain" });
@@ -600,12 +1099,12 @@ function stringifyExt(obj) {
 }
 function projectRoot() {
   if (process4.env.ARGON_PROJECT_ROOT) {
-    return Path6.join(process4.env.ARGON_PROJECT_ROOT);
+    return Path7.join(process4.env.ARGON_PROJECT_ROOT);
   }
-  return Path6.join(__dirname, `../../..`);
+  return Path7.join(__dirname, `../../..`);
 }
 async function runTestScript(relativePath) {
-  const scriptPath = Path6.resolve(projectRoot(), relativePath);
+  const scriptPath = Path7.resolve(projectRoot(), relativePath);
   return child_process4.execSync(scriptPath, { encoding: "utf8" }).trim();
 }
 async function getDockerPortMapping(containerName, port2) {
@@ -655,16 +1154,19 @@ async function activateNotary(sudo2, client, notary) {
 export {
   SKIP_E2E,
   TestBitcoinCli,
+  TestEthereum,
   TestMainchain,
   TestNotary,
   TestOracle,
   activateNotary,
   addTeardown,
+  argonTokenArtifact,
   cleanHostForDocker,
   closeOnTeardown,
   disconnectOnTeardown,
   getDockerPortMapping,
   getProxy,
+  mintingGatewayArtifact,
   projectRoot,
   runOnTeardown,
   runTestScript,