@argonprotocol/testing 1.4.3-dev.4408f4ff → 1.4.3-dev.4544e954

package/lib/index.js

@@ -6,23 +6,114 @@ var getDirname = () => path.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
 // src/index.ts
-import { Keyring as Keyring3, TxSubmitter as TxSubmitter2 } from "@argonprotocol/mainchain";
-import * as process4 from "process";
-import HttpProxy from "http-proxy";
-import * as child_process4 from "child_process";
-import * as http2 from "http";
-import * as url from "url";
-import * as Path7 from "path";
+import { Keyring as Keyring4, TxSubmitter as TxSubmitter4 } from "@argonprotocol/mainchain";
 
 // src/TestNotary.ts
 import { customAlphabet } from "nanoid";
 import pg from "pg";
-import * as child_process from "child_process";
+import * as child_process2 from "child_process";
 import { Keyring, TxSubmitter } from "@argonprotocol/mainchain";
 import * as fs from "fs";
 import * as readline from "readline";
+
+// src/support.ts
 import * as process2 from "process";
+import HttpProxy from "http-proxy";
+import * as child_process from "child_process";
+import * as http from "http";
+import * as url from "url";
 import * as Path from "path";
+var toTeardown = [];
+var proxy = null;
+var proxyServer = null;
+var SKIP_E2E = process2.env.SKIP_E2E === "true" || process2.env.SKIP_E2E === "1";
+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 port2 = proxyServer.address().port;
+  return `ws://host.docker.internal:${port2}`;
+}
+function projectRoot() {
+  if (process2.env.ARGON_PROJECT_ROOT) {
+    return Path.join(process2.env.ARGON_PROJECT_ROOT);
+  }
+  return Path.join(__dirname, `../../..`);
+}
+async function runTestScript(relativePath) {
+  const scriptPath = Path.resolve(projectRoot(), relativePath);
+  return child_process.execSync(scriptPath, { encoding: "utf8" }).trim();
+}
+async function getDockerPortMapping(containerName, port2) {
+  return child_process.execSync(`docker port ${containerName} ${port2}`, { 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 (process2.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 runOnTeardown(teardown2) {
+  addTeardown({ teardown: teardown2 });
+}
+function closeOnTeardown(closeable) {
+  addTeardown({ teardown: () => closeable.close() });
+  return closeable;
+}
+function disconnectOnTeardown(closeable) {
+  addTeardown({ teardown: () => closeable.disconnect() });
+  return closeable;
+}
+
+// src/TestNotary.ts
+import * as process3 from "process";
+import * as Path2 from "path";
 var { Client: PgClient } = pg;
 var nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 4);
 function createUid() {
@@ -48,7 +139,7 @@ var TestNotary = class {
     return `ws://${this.ip}:${this.port}`;
   }
   constructor(dbConnectionString) {
-    this.#dbConnectionString = dbConnectionString ?? process2.env.NOTARY_DB_URL ?? "postgres://postgres:postgres@localhost:5432";
+    this.#dbConnectionString = dbConnectionString ?? process3.env.NOTARY_DB_URL ?? "postgres://postgres:postgres@localhost:5432";
     addTeardown(this);
   }
   /**
@@ -60,10 +151,10 @@ var TestNotary = class {
     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) {
+    let notaryPath = pathToNotaryBin ?? Path2.join(projectRoot(), "target/debug/argon-notary");
+    if (process3.env.ARGON_USE_DOCKER_BINS) {
       this.containerName = "notary_" + uuid;
-      const addHost = process2.env.ADD_DOCKER_HOST ? ` --add-host=host.docker.internal:host-gateway` : "";
+      const addHost = process3.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)) {
@@ -86,7 +177,7 @@ var TestNotary = class {
     } finally {
       await client.end();
     }
-    const result = child_process.execSync(
+    const result = child_process2.execSync(
       `${notaryPath} migrate --db-url ${this.#dbConnectionString}/${this.#dbName}`,
       {
         encoding: "utf-8"
@@ -109,18 +200,18 @@ var TestNotary = class {
       `--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";
+    if (process3.env.ARGON_USE_DOCKER_BINS) {
+      process3.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}`);
+    if (process3.env.AWS_S3_ENDPOINT) {
+      execArgs.push(`--archive-endpoint=${process3.env.AWS_S3_ENDPOINT}`);
     }
-    this.#childProcess = child_process.spawn(notaryPath, execArgs, {
+    this.#childProcess = child_process2.spawn(notaryPath, execArgs, {
       stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process2.env, RUST_LOG: "warn" }
+      env: { ...process3.env, RUST_LOG: "warn" }
     });
     this.#childProcess.stdout.setEncoding("utf8");
     this.#childProcess.stderr.setEncoding("utf8");
@@ -177,7 +268,7 @@ var TestNotary = class {
     }
     if (this.containerName) {
       try {
-        child_process.execSync(`docker rm -f ${this.containerName}`);
+        child_process2.execSync(`docker rm -f ${this.containerName}`);
       } catch {
       }
     }
@@ -196,15 +287,15 @@ var TestNotary = class {
 
 // src/TestMainchain.ts
 import * as fs2 from "fs";
-import { execSync as execSync2, spawn as spawn2 } from "child_process";
-import * as Path2 from "path";
+import { execSync as execSync3, spawn as spawn2 } from "child_process";
+import * as Path3 from "path";
 import * as readline2 from "readline";
 import { detectPort } from "detect-port";
 import { customAlphabet as customAlphabet2 } from "nanoid";
 import * as lockfile from "proper-lockfile";
 import { getClient } from "@argonprotocol/mainchain";
 var nanoid2 = customAlphabet2("0123456789abcdefghijklmnopqrstuvwxyz", 4);
-var lockPath = Path2.join(process.cwd(), ".port-lock");
+var lockPath = Path3.join(process.cwd(), ".port-lock");
 var TestMainchain = class {
   ip = "127.0.0.1";
   port;
@@ -227,8 +318,8 @@ var TestMainchain = class {
     return `ws://${this.ip}:${this.port}`;
   }
   constructor(binPath) {
-    this.#binPath = binPath ?? Path2.join(projectRoot(), `target/debug/argon-node`);
-    this.#binPath = Path2.resolve(this.#binPath);
+    this.#binPath = binPath ?? Path3.join(projectRoot(), `target/debug/argon-node`);
+    this.#binPath = Path3.resolve(this.#binPath);
     if (!process.env.ARGON_USE_DOCKER_BINS && !fs2.existsSync(this.#binPath)) {
       throw new Error(`Mainchain binary not found at ${this.#binPath}`);
     }
@@ -355,7 +446,7 @@ var TestMainchain = class {
   async teardown() {
     if (process.env.ARGON_USE_DOCKER_BINS) {
       try {
-        execSync2(`docker rm -f ${this.containerName}`);
+        execSync3(`docker rm -f ${this.containerName}`);
       } catch {
       }
     }
@@ -389,7 +480,7 @@ var TestMainchain = class {
       const release = await lockfile.lock(lockPath, { retries: 10 });
       try {
         rpcPort = await detectPort();
-        const path2 = execSync2(Path2.join(projectRoot(), `target/debug/argon-testing-bitcoin`), {
+        const path2 = execSync3(Path3.join(projectRoot(), `target/debug/argon-testing-bitcoin`), {
           encoding: "utf8"
         }).trim();
         const tmpDir = fs2.mkdtempSync("/tmp/argon-bitcoin-" + this.uuid);
@@ -477,16 +568,16 @@ var BitcoinRpcClient = class {
 };
 
 // src/TestBitcoinCli.ts
-import * as child_process2 from "child_process";
-import * as Path3 from "path";
+import * as child_process3 from "child_process";
+import * as Path4 from "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");
+    const binPath = Path4.join(`${projectRoot()}`, "target/debug/argon-bitcoin-cli");
     try {
-      return child_process2.execSync(`${binPath} ${command}`, {
+      return child_process3.execSync(`${binPath} ${command}`, {
         encoding: "utf8"
       }).trim();
     } catch (e) {
@@ -498,12 +589,12 @@ var TestBitcoinCli = class {
 };
 
 // src/TestOracle.ts
-import * as child_process3 from "child_process";
+import * as child_process4 from "child_process";
 import { Keyring as Keyring2 } from "@argonprotocol/mainchain";
 import * as fs3 from "fs";
 import * as readline3 from "readline";
-import * as process3 from "process";
-import * as Path4 from "path";
+import * as process4 from "process";
+import * as Path5 from "path";
 var TestOracle = class _TestOracle {
   static BitcoinOperator = "//Dave";
   static PriceIndexOperator = "//Eve";
@@ -518,7 +609,7 @@ var TestOracle = class _TestOracle {
     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");
+    const binPath = pathToBin ?? Path5.join(projectRoot(), "target/debug/argon-oracle");
     if (!fs3.existsSync(binPath)) {
       throw new Error(`Oracle binary not found at ${binPath}`);
     }
@@ -530,9 +621,9 @@ var TestOracle = class _TestOracle {
       }
       execArgs.push("--bitcoin-rpc-url", bitcoinRpcUrl);
     }
-    this.#childProcess = child_process3.spawn(binPath, execArgs, {
+    this.#childProcess = child_process4.spawn(binPath, execArgs, {
       stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process3.env, RUST_LOG: "info", ...options.env }
+      env: { ...process4.env, RUST_LOG: "info", ...options.env }
     });
     this.#childProcess.stdout.setEncoding("utf8");
     this.#childProcess.stderr.setEncoding("utf8");
@@ -555,24 +646,10 @@ var TestOracle = class _TestOracle {
 // src/TestEthereum.ts
 import * as fs4 from "fs/promises";
 import * as os from "os";
-import * as Path5 from "path";
+import * as Path6 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 { EvmContracts } from "@argonprotocol/mainchain";
 import { privateKeyToAccount } from "viem/accounts";
 import {
   createPublicClient,
@@ -580,9 +657,17 @@ import {
   defineChain,
   encodeFunctionData,
   getAddress,
-  http,
+  http as http2,
   zeroAddress
 } from "viem";
+var {
+  argonTokenArtifact,
+  argonotTokenArtifact,
+  hashMintingGatewayGlobalIssuanceCouncil,
+  mintingGatewayArtifact,
+  proxyAdminArtifact,
+  transparentUpgradeableProxyArtifact
+} = EvmContracts;
 var DEFAULT_KURTOSIS_BIN = "kurtosis";
 var DEFAULT_ETHEREUM_PACKAGE = "github.com/ethpandaops/ethereum-package";
 var DEFAULT_EL_PORT_START = 32e3;
@@ -594,6 +679,7 @@ 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 DEFAULT_INITIAL_MICROGONS_PER_ARGONOT = 1000000n;
 var ERC1967_ADMIN_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
 var TestEthereum = class {
   enclaveName;
@@ -622,8 +708,8 @@ var TestEthereum = class {
     } = 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");
+    this.#argsDir = await fs4.mkdtemp(Path6.join(os.tmpdir(), "argon-ethereum-devnet-"));
+    const argsFile = Path6.join(this.#argsDir, "network-params.yaml");
     await fs4.writeFile(
       argsFile,
       renderEthereumArgs(
@@ -713,12 +799,21 @@ var TestEthereum = class {
     const chain = createExecutionChain(chainId, executionRpcUrl);
     const publicClient = createPublicClient({
       chain,
-      transport: http(executionRpcUrl)
+      transport: http2(executionRpcUrl)
     });
     const walletClient = createWalletClient({
       account,
       chain,
-      transport: http(executionRpcUrl)
+      transport: http2(executionRpcUrl)
+    });
+    const bootstrapCouncil = {
+      signers: [adminSafe],
+      weights: [1n]
+    };
+    const initialMicrogonsPerArgonot = options.initialMicrogonsPerArgonot ?? DEFAULT_INITIAL_MICROGONS_PER_ARGONOT;
+    const bootstrapCouncilHash = hashMintingGatewayGlobalIssuanceCouncil({
+      ...bootstrapCouncil,
+      epochMicrogonsPerArgonot: initialMicrogonsPerArgonot
     });
     const bootstrapImplementationAddress = await deployContract(walletClient, publicClient, {
       abi: mintingGatewayArtifact.abi,
@@ -728,7 +823,14 @@ var TestEthereum = class {
     const initializeData = encodeFunctionData({
       abi: mintingGatewayArtifact.abi,
       functionName: "initialize",
-      args: [adminSafe, guardianSafe]
+      args: [
+        adminSafe,
+        guardianSafe,
+        bootstrapCouncilHash,
+        BigInt(bootstrapCouncil.signers.length),
+        1n,
+        initialMicrogonsPerArgonot
+      ]
     });
     const gatewayAddress = await deployContract(walletClient, publicClient, {
       abi: transparentUpgradeableProxyArtifact.abi,
@@ -773,17 +875,22 @@ var TestEthereum = class {
         to: gatewayAddress,
         data: encodeFunctionData({
           abi: mintingGatewayArtifact.abi,
-          functionName: "adminMintBatch",
+          functionName: "migrate",
           args: [
-            argonTokenAddress,
-            [options.seedArgonRecipient],
-            [options.seedArgonAmountBaseUnits ?? DEFAULT_SEED_ARGON_AMOUNT_BASE_UNITS]
+            {
+              recipients: [options.seedArgonRecipient],
+              amounts: [options.seedArgonAmountBaseUnits ?? DEFAULT_SEED_ARGON_AMOUNT_BASE_UNITS]
+            },
+            {
+              recipients: [],
+              amounts: []
+            }
           ]
         })
       });
       const mintReceipt = await waitForExecutionReceipt(publicClient, mintHash);
       if (mintReceipt.status !== "success") {
-        throw new Error("MintingGateway admin mint failed");
+        throw new Error("MintingGateway migrate failed");
       }
     }
     return {
@@ -1002,9 +1109,9 @@ async function delay(ms) {
 
 // src/TestNetwork.ts
 import * as docker from "docker-compose";
-import * as Path6 from "path";
+import * as Path7 from "path";
 async function startNetwork(testName, options) {
-  const config = Path6.join(__dirname, `dev.docker-compose.yml`);
+  const config = Path7.join(__dirname, `dev.docker-compose.yml`);
   const env4 = {
     VERSION: "dev",
     ARGON_CHAIN: "dev-docker",
@@ -1036,52 +1143,1081 @@ async function startNetwork(testName, options) {
   };
 }
 
-// src/index.ts
-var toTeardown = [];
-var proxy = null;
-var proxyServer = null;
-var SKIP_E2E = process4.env.SKIP_E2E === "true" || process4.env.SKIP_E2E === "1";
-async function getProxy() {
-  if (!proxy) {
-    proxy = HttpProxy.createProxyServer({
-      changeOrigin: true,
-      ws: true,
-      autoRewrite: true
+// src/EthereumE2eUtils.ts
+import {
+  getLatestArgonFinalizedExecutionHeader,
+  getNextEthereumBeaconSyncTxs,
+  hexToU8a,
+  isOutdatedTransactionError,
+  TxSubmitter as TxSubmitter2,
+  u8aToHex
+} from "@argonprotocol/mainchain";
+import { parseSignature } from "viem";
+async function signGatewayPermit(args) {
+  const signature = parseSignature(
+    await args.account.signTypedData({
+      domain: {
+        name: "Argon",
+        version: "1",
+        chainId: args.chainId,
+        verifyingContract: args.tokenAddress
+      },
+      types: {
+        Permit: [
+          { name: "owner", type: "address" },
+          { name: "spender", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "nonce", type: "uint256" },
+          { name: "deadline", type: "uint256" }
+        ]
+      },
+      primaryType: "Permit",
+      message: {
+        owner: args.owner,
+        spender: args.gatewayAddress,
+        value: args.value,
+        nonce: args.nonce,
+        deadline: args.deadline
+      }
+    })
+  );
+  return {
+    v: Number(signature.v),
+    r: signature.r,
+    s: signature.s
+  };
+}
+async function waitForFinalizedBeaconExecutionAtOrAbove(ethereum, minimumExecutionBlockNumber, options = {}) {
+  const startedAt = Date.now();
+  const minimumFinalizedSlot = options.minimumFinalizedSlot ?? 0n;
+  let lastSeenExecutionBlockNumber = 0n;
+  let lastSeenHeadSlot = 0n;
+  let lastSeenFinalizedSlot = 0n;
+  let lastError;
+  while (Date.now() - startedAt < 3e5) {
+    try {
+      const [headHeader, finalizedHeader] = await Promise.all([
+        ethereum.getBeacon("/eth/v1/beacon/headers/head"),
+        ethereum.getBeacon("/eth/v1/beacon/headers/finalized")
+      ]);
+      lastSeenHeadSlot = BigInt(headHeader.data.header.message.slot);
+      lastSeenFinalizedSlot = BigInt(finalizedHeader.data.header.message.slot);
+      const block = await ethereum.getBeacon(
+        `/eth/v2/beacon/blocks/${finalizedHeader.data.root}`
+      );
+      const executionBlockNumber = BigInt(block.data.message.body.execution_payload.block_number);
+      lastSeenExecutionBlockNumber = executionBlockNumber;
+      lastError = void 0;
+      if (executionBlockNumber >= minimumExecutionBlockNumber && lastSeenFinalizedSlot >= minimumFinalizedSlot) {
+        return { header: finalizedHeader, block };
+      }
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
+      }
+      lastError = error;
+    }
+    await delay2(1e3);
+  }
+  const lastErrorSuffix = lastError ? `; last beacon error was: ${lastError.message}` : "";
+  throw new Error(
+    `Timed out waiting for finalized beacon execution block at or above ${minimumExecutionBlockNumber} and finalized slot at or above ${minimumFinalizedSlot}; last seen head slot was ${lastSeenHeadSlot}, finalized slot was ${lastSeenFinalizedSlot}, and finalized execution block was ${lastSeenExecutionBlockNumber}${lastErrorSuffix}`
+  );
+}
+async function mineLaterExecutionAnchorReceipt(walletClient, chain, ethereum, account, minimumBlockNumber) {
+  while (true) {
+    const transactionHash = await walletClient.sendTransaction({
+      account,
+      chain,
+      to: account.address,
+      value: 0n
     });
-    proxy.on("error", () => null);
-    proxyServer = http2.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");
+    const receipt = await waitForExecutionReceipt2(ethereum, transactionHash);
+    if (BigInt(receipt.blockNumber) > minimumBlockNumber) {
+      return receipt;
+    }
+  }
+}
+async function waitForExecutionReceipt2(ethereum, transactionHash) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < 12e4) {
+    try {
+      const receipt = await ethereum.callExecution(
+        "eth_getTransactionReceipt",
+        [transactionHash]
+      );
+      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")) {
+        throw error;
+      }
+    }
+    await delay2(500);
+  }
+  throw new Error(`Timed out waiting for execution receipt ${transactionHash}`);
+}
+async function syncEthereumVerifierUntilAnchorCovers(mainchainClient, relayer, beaconApiUrl, minimumExecutionBlockNumber) {
+  const startedAt = Date.now();
+  const timeoutMs = 5 * 6e4;
+  let lastRetryableError;
+  let lastAnchorBlockNumber;
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const anchor = await getLatestArgonFinalizedExecutionHeader(mainchainClient);
+      lastAnchorBlockNumber = anchor.blockNumber;
+      if (anchor.blockNumber >= minimumExecutionBlockNumber) {
         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
+    } catch {
+    }
+    const txs = await getNextEthereumBeaconSyncTxs(mainchainClient, beaconApiUrl);
+    if (txs.length === 0) {
+      await delay2(500);
+      continue;
+    }
+    let shouldRetry = false;
+    for (const tx of txs) {
+      try {
+        const result = await new TxSubmitter2(mainchainClient, tx, relayer).submit();
+        await result.waitForInFirstBlock;
+        lastRetryableError = void 0;
+      } catch (error) {
+        if (isRetryableEthereumVerifierSyncError(error)) {
+          lastRetryableError = error instanceof Error ? error : new Error(String(error));
+          shouldRetry = true;
+          break;
+        }
+        throw error;
+      }
+    }
+    if (shouldRetry) {
+      await delay2(500);
+    }
+  }
+  throw lastRetryableError ?? new Error(
+    `Ethereum verifier did not retain an anchor at or above execution block ${minimumExecutionBlockNumber} within ${Math.floor(timeoutMs / 1e3)}s; last seen anchor was ${lastAnchorBlockNumber ?? "unavailable"}`
+  );
+}
+function toArgonKeccakSignature(signature) {
+  const bytes = hexToU8a(signature);
+  if (bytes.length !== 65) {
+    throw new Error(`Expected 65-byte ECDSA signature, received ${bytes.length} bytes`);
+  }
+  if (bytes[64] >= 27) {
+    bytes[64] -= 27;
+  }
+  return u8aToHex(bytes);
+}
+function toEvmRecoverableSignature(signature) {
+  const bytes = hexToU8a(signature);
+  if (bytes.length !== 65) {
+    throw new Error(`Expected 65-byte ECDSA signature, received ${bytes.length} bytes`);
+  }
+  if (bytes[64] <= 1) {
+    bytes[64] += 27;
+  }
+  return u8aToHex(bytes);
+}
+function isRetryableEthereumVerifierSyncError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return isOutdatedTransactionError(error) || message.includes("ethereumVerifier.InvalidHeaderMerkleProof");
+}
+async function delay2(ms) {
+  await new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/EthereumGatewayQueue.ts
+import {
+  EvmContracts as EvmContracts2
+} from "@argonprotocol/mainchain";
+import { getAddress as getAddress2, keccak256 } from "viem";
+var {
+  encodeMintingGatewayMintingAuthorityActivationTarget,
+  encodeMintingGatewayMintingAuthorityDeactivateTarget,
+  hashMintingGatewayActivateMintingAuthority,
+  hashMintingGatewayGatewayUpdateApproval,
+  hashMintingGatewayMintingAuthorityDeactivation,
+  mintingGatewayAbi,
+  MINTING_GATEWAY_UPDATE_KINDS
+} = EvmContracts2;
+async function getReadyEthereumGatewayUpdates(client, gatewayClient, options = {}) {
+  const destinationChain = options.destinationChain ?? "Ethereum";
+  const maxQueueEntries = options.maxQueueEntries ?? 100;
+  if (maxQueueEntries < 1) {
+    throw new Error(`maxQueueEntries must be at least 1, received ${maxQueueEntries}`);
+  }
+  const chainConfigOption = await client.query.crosschainTransfer.chainConfigBySourceChain(destinationChain);
+  if (chainConfigOption.isNone) {
+    throw new Error(`Crosschain config not found for ${destinationChain}`);
+  }
+  const chainConfig = chainConfigOption.unwrap();
+  if (!chainConfig.isEvm) {
+    throw new Error(`Chain config for ${destinationChain} is not EVM-shaped`);
+  }
+  const gatewayAddress = getAddress2(toHexValue(chainConfig.asEvm.gateway));
+  const chainId = chainConfig.asEvm.chainId.toBigInt();
+  const hashContext = { chainId, gatewayAddress };
+  const currentCouncilHashOption = await client.query.crosschainTransfer.activeGlobalIssuanceCouncilByDestinationChain(
+    destinationChain
+  );
+  if (currentCouncilHashOption.isNone) {
+    throw new Error(`Active GlobalIssuanceCouncil not found for ${destinationChain}`);
+  }
+  const currentCouncilHash = toHexValue(currentCouncilHashOption.unwrap());
+  const councilCache = /* @__PURE__ */ new Map();
+  const currentCouncil = councilToSnapshot(
+    await loadCouncilByHash(client, currentCouncilHash, councilCache)
+  );
+  const [rawArgonApprovalsNonce, rawArgonApprovalsHash, rawPaused] = await Promise.all([
+    gatewayClient.readContract({
+      abi: mintingGatewayAbi,
+      address: gatewayAddress,
+      functionName: "argonApprovalsNonce"
+    }),
+    gatewayClient.readContract({
+      abi: mintingGatewayAbi,
+      address: gatewayAddress,
+      functionName: "argonApprovalsHash"
+    }),
+    gatewayClient.readContract({
+      abi: mintingGatewayAbi,
+      address: gatewayAddress,
+      functionName: "paused"
+    })
+  ]);
+  const argonApprovalsNonce = rawArgonApprovalsNonce;
+  const argonApprovalsHash = rawArgonApprovalsHash;
+  const paused = rawPaused;
+  const pendingClearOutQueueNonces = [];
+  const candidateUpdates = [];
+  let expectedPreviousApprovalHash = argonApprovalsHash;
+  let readyQueueEntriesScanned = 0;
+  if (!paused) {
+    for (let queueNonce = argonApprovalsNonce + 1n; readyQueueEntriesScanned < maxQueueEntries; queueNonce += 1n) {
+      const entryOption = await client.query.crosschainTransfer.councilApprovalQueueByDestinationChainAndNonce(
+        destinationChain,
+        queueNonce
+      );
+      if (entryOption.isNone) {
+        break;
+      }
+      const entry = entryOption.unwrap();
+      const approvingCouncilHash = toHexValue(entry.approvingCouncilHash);
+      if (!await queueEntryIsReady(
+        client,
+        entry,
+        approvingCouncilHash,
+        councilCache,
+        hashContext,
+        queueNonce
+      )) {
+        break;
+      }
+      readyQueueEntriesScanned += 1;
+      if (toHexValue(entry.previousApprovalHash) !== expectedPreviousApprovalHash) {
+        throw new Error(
+          `Queue nonce ${queueNonce} expected previous approval hash ${expectedPreviousApprovalHash}, received ${toHexValue(entry.previousApprovalHash)}`
+        );
+      }
+      const update = await buildGatewayUpdate(client, destinationChain, hashContext, queueNonce, {
+        entry,
+        approvingCouncilHash
       });
-      clientSocket.on("error", console.error);
+      candidateUpdates.push(update);
+      expectedPreviousApprovalHash = toHexValue(entry.approvalHash);
+    }
+  }
+  while (candidateUpdates.length > 0 && candidateUpdates[candidateUpdates.length - 1]?.kind === MINTING_GATEWAY_UPDATE_KINDS.mintingAuthorityDeactivate) {
+    pendingClearOutQueueNonces.unshift(candidateUpdates.pop().queueNonce);
+  }
+  const updates = candidateUpdates;
+  const firstQueueNonce = updates[0]?.queueNonce;
+  const lastQueueNonce = updates[updates.length - 1]?.queueNonce;
+  return {
+    destinationChain,
+    chainId,
+    gatewayAddress,
+    currentCouncilHash,
+    currentCouncil,
+    argonApprovalsNonce,
+    argonApprovalsHash,
+    paused,
+    pendingClearOutQueueNonces,
+    ...firstQueueNonce !== void 0 ? { firstQueueNonce, lastQueueNonce } : {},
+    updates
+  };
+}
+async function buildGatewayUpdate(client, destinationChain, hashContext, queueNonce, queueItem) {
+  const { entry, approvingCouncilHash } = queueItem;
+  if (entry.target.isMintingAuthorityActivation) {
+    const signatures = getSortedSignatures(entry.signatures);
+    const signingKey = getAddress2(toHexValue(entry.target.asMintingAuthorityActivation));
+    const authorityOption = await client.query.crosschainTransfer.mintingAuthoritiesBySigner(signingKey);
+    if (authorityOption.isNone) {
+      throw new Error(
+        `Minting authority activation ${signingKey} not found for queue nonce ${queueNonce}`
+      );
+    }
+    const authority = authorityOption.unwrap();
+    if (authority.destinationChain.type !== destinationChain) {
+      throw new Error(
+        `Minting authority ${signingKey} belongs to ${String(authority.destinationChain.type)}, expected ${String(destinationChain)}`
+      );
+    }
+    const target = {
+      microgonCollateral: authority.gatewayRemainingMicrogonCollateral.toBigInt(),
+      micronotCollateral: authority.gatewayRemainingMicronotCollateral.toBigInt(),
+      signingKey
+    };
+    const payload = encodeMintingGatewayMintingAuthorityActivationTarget(target);
+    const targetPayloadHash = payloadHashFromActivationPayload(hashContext, target);
+    const approvalHash = hashMintingGatewayGatewayUpdateApproval(hashContext, {
+      queueNonce,
+      approvingCouncilHash,
+      kind: MINTING_GATEWAY_UPDATE_KINDS.mintingAuthorityActivate,
+      targetId: `0x${signingKey.slice(2).padStart(64, "0").toLowerCase()}`,
+      targetPayloadHash,
+      previousUpdateHash: toHexValue(entry.previousApprovalHash)
     });
-    await new Promise((resolve3) => proxyServer.listen(0, resolve3));
-    toTeardown.push({
-      teardown: () => new Promise((resolve3) => {
-        proxy?.close();
-        proxyServer?.close((_) => null);
-        proxy = null;
-        proxyServer = null;
-        resolve3();
+    if (toHexValue(entry.targetPayloadHash) !== targetPayloadHash) {
+      throw new Error(`Queue nonce ${queueNonce} target payload hash does not match authority`);
+    }
+    if (toHexValue(entry.approvalHash) !== approvalHash) {
+      throw new Error(
+        `Queue nonce ${queueNonce} approval hash does not match authority: actual=${toHexValue(entry.approvalHash)} expected=${approvalHash} previous=${toHexValue(entry.previousApprovalHash)} council=${approvingCouncilHash} targetPayload=${toHexValue(entry.targetPayloadHash)}`
+      );
+    }
+    return {
+      queueNonce,
+      kind: MINTING_GATEWAY_UPDATE_KINDS.mintingAuthorityActivate,
+      payload,
+      signatures
+    };
+  }
+  if (entry.target.isMintingAuthorityDeactivation) {
+    const { payload, signatures } = validateDeactivationEntry(
+      hashContext,
+      queueNonce,
+      entry,
+      approvingCouncilHash
+    );
+    return {
+      queueNonce,
+      kind: MINTING_GATEWAY_UPDATE_KINDS.mintingAuthorityDeactivate,
+      payload,
+      signatures
+    };
+  }
+  throw new Error(`Unsupported approval queue target ${entry.target.type}`);
+}
+async function loadCouncilByHash(client, councilHash, cache) {
+  const cached = cache.get(councilHash);
+  if (cached) {
+    return cached;
+  }
+  const councilOption = await client.query.crosschainTransfer.globalIssuanceCouncilByHash(councilHash);
+  if (councilOption.isNone) {
+    throw new Error(`GlobalIssuanceCouncil ${councilHash} not found`);
+  }
+  const council = councilOption.unwrap();
+  const loaded = {
+    totalWeight: council.totalWeight.toBigInt(),
+    members: [...council.members.entries()].map(([signer, member]) => ({
+      signer: getAddress2(toHexValue(signer)),
+      weight: member.weight.toBigInt()
+    })).sort((left, right) => left.signer.localeCompare(right.signer))
+  };
+  cache.set(councilHash, loaded);
+  return loaded;
+}
+function queueEntryHasQuorum(entry, council) {
+  const signedWeight = [...entry.signatures.entries()].reduce((total, [signer]) => {
+    const signerAddress = getAddress2(toHexValue(signer));
+    const member = council.members.find((x) => x.signer === signerAddress);
+    if (!member) {
+      throw new Error(`Signature submitted by ${signerAddress}, which is not in the council`);
+    }
+    return total + member.weight;
+  }, 0n);
+  return signedWeight * 2n > council.totalWeight;
+}
+async function queueEntryIsReady(client, entry, approvingCouncilHash, councilCache, hashContext, queueNonce) {
+  if (entry.target.isMintingAuthorityDeactivation) {
+    validateDeactivationEntry(hashContext, queueNonce, entry, approvingCouncilHash);
+    return true;
+  }
+  const approvingCouncil = await loadCouncilByHash(client, approvingCouncilHash, councilCache);
+  return queueEntryHasQuorum(entry, approvingCouncil);
+}
+function councilToSnapshot(council) {
+  return {
+    signers: council.members.map((member) => member.signer),
+    weights: council.members.map((member) => member.weight)
+  };
+}
+function payloadHashFromActivationPayload(hashContext, target) {
+  return hashMintingGatewayActivateMintingAuthority(hashContext, target);
+}
+function payloadHashFromDeactivationPayload(target) {
+  return keccak256(encodeMintingGatewayMintingAuthorityDeactivateTarget(target));
+}
+function validateDeactivationEntry(hashContext, queueNonce, entry, approvingCouncilHash) {
+  const signingKey = getAddress2(toHexValue(entry.target.asMintingAuthorityDeactivation));
+  const target = { signingKey };
+  const payload = encodeMintingGatewayMintingAuthorityDeactivateTarget(target);
+  const targetPayloadHash = payloadHashFromDeactivationPayload(target);
+  const approvalHash = hashMintingGatewayMintingAuthorityDeactivation(hashContext, {
+    queueNonce,
+    target,
+    previousUpdateHash: toHexValue(entry.previousApprovalHash)
+  });
+  if (toHexValue(entry.targetPayloadHash) !== targetPayloadHash) {
+    throw new Error(`Queue nonce ${queueNonce} target payload hash does not match deactivation`);
+  }
+  if (toHexValue(entry.approvalHash) !== approvalHash) {
+    throw new Error(
+      `Queue nonce ${queueNonce} approval hash does not match deactivation: actual=${toHexValue(entry.approvalHash)} expected=${approvalHash} previous=${toHexValue(entry.previousApprovalHash)} council=${approvingCouncilHash}`
+    );
+  }
+  const deactivationSignatures = [...entry.signatures.entries()];
+  if (deactivationSignatures.length !== 1) {
+    throw new Error(
+      `Queue nonce ${queueNonce} expected exactly one deactivation signature, received ${deactivationSignatures.length}`
+    );
+  }
+  const [signer] = deactivationSignatures[0];
+  if (getAddress2(toHexValue(signer)) !== signingKey) {
+    throw new Error(
+      `Queue nonce ${queueNonce} deactivation signature was submitted by ${getAddress2(toHexValue(signer))}, expected ${signingKey}`
+    );
+  }
+  return {
+    payload,
+    signatures: getSortedSignatures(entry.signatures)
+  };
+}
+function getSortedSignatures(signatures) {
+  return [...signatures.entries()].sort(
+    ([leftSigner], [rightSigner]) => toHexValue(leftSigner).localeCompare(toHexValue(rightSigner))
+  ).map(([, signature]) => toEvmRecoverableSignature(toHexValue(signature)));
+}
+function toHexValue(value) {
+  return value.toHex();
+}
+
+// src/TestEthereumProofActors.ts
+import {
+  buildGatewayActivityProofPayload,
+  decodeAddress,
+  dispatchErrorToString,
+  EvmContracts as EvmContracts3,
+  getEthereumBeaconSyncBootstrapTx,
+  Keyring as Keyring3,
+  toFixedNumber,
+  TxSubmitter as TxSubmitter3,
+  U8aFixed,
+  Vault,
+  Vec
+} from "@argonprotocol/mainchain";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient as createWalletClient3,
+  defineChain as defineChain3,
+  encodeFunctionData as encodeFunctionData2,
+  http as http3,
+  toHex
+} from "viem";
+var { argonTokenAbi, mintingGatewayAbi: mintingGatewayAbi2, MINTING_GATEWAY_RUNTIME_TO_ERC20_SCALE } = EvmContracts3;
+var MINIMAL_BOOTSTRAP_FINALIZED_SLOT = 64n;
+var EthereumProofE2eHarness = class _EthereumProofE2eHarness {
+  constructor(ethereum, endpoints, mainchain, mainchainClient, deployerPrivateKey, proofRelayerUri) {
+    this.ethereum = ethereum;
+    this.endpoints = endpoints;
+    this.mainchain = mainchain;
+    this.mainchainClient = mainchainClient;
+    this.deployer = privateKeyToAccount2(deployerPrivateKey);
+    this.chain = defineChain3({
+      id: Number.parseInt(endpoints.chainId, 16),
+      name: "argon-test-ethereum",
+      nativeCurrency: {
+        name: "Ether",
+        symbol: "ETH",
+        decimals: 18
+      },
+      rpcUrls: {
+        default: {
+          http: [endpoints.executionRpcUrl]
+        }
+      }
+    });
+    this.publicClient = createPublicClient2({
+      chain: this.chain,
+      transport: http3(endpoints.executionRpcUrl)
+    });
+    this.walletClient = createWalletClient3({
+      account: this.deployer,
+      chain: this.chain,
+      transport: http3(endpoints.executionRpcUrl)
+    });
+    this.proofRelayer = new Keyring3({ type: "sr25519" }).createFromUri(proofRelayerUri);
+  }
+  sudoSigner = new Keyring3({ type: "sr25519" }).createFromUri("//Alice");
+  deployer;
+  chain;
+  publicClient;
+  walletClient;
+  mainchainClient;
+  proofRelayer;
+  static async launch(args) {
+    const ethereum = new TestEthereum();
+    const endpoints = await ethereum.launch({
+      consensusClient: "lodestar",
+      preset: "minimal",
+      secondsPerSlot: 1,
+      prefundedAccounts: {
+        [args.testAccount.address]: {
+          balance: args.testAccount.balance
+        }
+      }
+    });
+    const mainchain = new TestMainchain();
+    await mainchain.launch();
+    const mainchainClient = await mainchain.client();
+    return new _EthereumProofE2eHarness(
+      ethereum,
+      endpoints,
+      mainchain,
+      mainchainClient,
+      args.testAccount.privateKey,
+      args.proofRelayerUri
+    );
+  }
+  async submit(tx, signer) {
+    const result = await new TxSubmitter3(this.mainchainClient, tx, signer).submit();
+    await result.waitForInFirstBlock;
+    return result;
+  }
+  async sudoSubmit(tx) {
+    const result = await this.submit(
+      this.mainchainClient.tx.sudo.sudo(tx),
+      this.sudoSigner
+    );
+    const sudoEvent = result.events.find((event) => this.mainchainClient.events.sudo.Sudid.is(event));
+    if (!sudoEvent || !this.mainchainClient.events.sudo.Sudid.is(sudoEvent)) {
+      throw new Error("sudo did not emit sudo.Sudid");
+    }
+    const sudoResult = sudoEvent.data[0];
+    if (sudoResult.isErr) {
+      throw new Error(
+        `sudo failed: ${dispatchErrorToString(this.mainchainClient, sudoResult.asErr)}`
+      );
+    }
+    return result;
+  }
+  async syncVerifierThrough(minimumExecutionBlockNumber) {
+    await syncEthereumVerifierUntilAnchorCovers(
+      this.mainchainClient,
+      this.sudoSigner,
+      this.endpoints.beaconApiUrl,
+      minimumExecutionBlockNumber
+    );
+  }
+  async proveGatewayActivity(gatewayAddress, throughExecutionBlockNumber) {
+    const payload = await buildGatewayActivityProofPayload(this.mainchainClient, {
+      executionRpcUrl: this.endpoints.executionRpcUrl,
+      gatewayAddress,
+      throughExecutionBlockNumber
+    });
+    if (!payload) {
+      throw new Error("Expected uncovered gateway activity to prove");
+    }
+    const result = await this.submit(
+      this.mainchainClient.tx.crosschainTransfer.proveGatewayActivity(
+        "Ethereum",
+        payload.previousGatewayActivityNonce,
+        payload.proof
+      ),
+      this.proofRelayer
+    );
+    return { payload, result };
+  }
+  async configureEthereumRuntime(gateway, mode) {
+    const calls = [
+      this.mainchainClient.tx.crosschainTransfer.setChainConfig("Ethereum", {
+        Evm: {
+          chainId: BigInt(this.chain.id).toString(),
+          gateway: gateway.gatewayAddress,
+          argonToken: gateway.argonTokenAddress,
+          argonotToken: gateway.argonotTokenAddress
+        }
+      })
+    ];
+    if (mode.kind === "outbound") {
+      const activationPricing = {
+        activationGasCost: BigInt(mode.activationPricing.activationGasCost),
+        signatureGasCost: BigInt(mode.activationPricing.signatureGasCost),
+        estimatedWeiPerGas: BigInt(mode.activationPricing.estimatedWeiPerGas),
+        estimatedMicrogonsPerEth: BigInt(mode.activationPricing.estimatedMicrogonsPerEth)
+      };
+      calls.push(
+        this.mainchainClient.tx.crosschainTransfer.setMintingAuthorityActivationRepaymentPricing(
+          "Ethereum",
+          {
+            activationGasCost: activationPricing.activationGasCost.toString(),
+            signatureGasCost: activationPricing.signatureGasCost.toString(),
+            estimatedWeiPerGas: activationPricing.estimatedWeiPerGas.toString(),
+            estimatedMicrogonsPerEth: activationPricing.estimatedMicrogonsPerEth.toString()
+          }
+        )
+      );
+      if (mode.minimumMintingAuthorityValue !== void 0) {
+        calls.push(
+          this.mainchainClient.tx.crosschainTransfer.setMinimumMintingAuthorityValue(
+            "Ethereum",
+            mode.minimumMintingAuthorityValue.toString()
+          )
+        );
+      }
+    }
+    calls.push(
+      await getEthereumBeaconSyncBootstrapTx(this.mainchainClient, this.endpoints.beaconApiUrl)
+    );
+    const result = await this.sudoSubmit(this.mainchainClient.tx.utility.batchAll(calls));
+    return { result };
+  }
+  async fundBurnAccount(amount) {
+    const burnAccount = this.mainchainClient.consts.crosschainTransfer.ethereumBurnAccount.toString();
+    return this.forceSetBalance(burnAccount, amount);
+  }
+  async fundProofRelayer(amount = this.mainchainClient.consts.balances.existentialDeposit.toBigInt() + 1000000n) {
+    return this.submit(
+      this.mainchainClient.tx.balances.transferAllowDeath(this.proofRelayer.address, amount),
+      this.sudoSigner
+    );
+  }
+  async forceSetBalance(address, amount) {
+    return this.sudoSubmit(this.mainchainClient.tx.balances.forceSetBalance(address, amount));
+  }
+  async forceSetOwnership(address, amount) {
+    return this.sudoSubmit(this.mainchainClient.tx.ownership.forceSetBalance(address, amount));
+  }
+  async waitForExecutionFinalizedAfter(minimumExecutionBlockNumber) {
+    const laterReceipt = await mineLaterExecutionAnchorReceipt(
+      this.walletClient,
+      this.chain,
+      this.ethereum,
+      this.deployer,
+      minimumExecutionBlockNumber
+    );
+    await waitForFinalizedBeaconExecutionAtOrAbove(
+      this.ethereum,
+      BigInt(laterReceipt.blockNumber),
+      {
+        // Matches the apps/pr/gateway-proof bootstrap guard for minimal devnets.
+        minimumFinalizedSlot: MINIMAL_BOOTSTRAP_FINALIZED_SLOT
+      }
+    );
+    return laterReceipt;
+  }
+};
+var TestMintingGateway = class _TestMintingGateway {
+  constructor(harness, deployment) {
+    this.harness = harness;
+    this.deployment = deployment;
+  }
+  static async deploy(harness, options) {
+    const deployment = await harness.ethereum.deployMintingGatewayFixture(options);
+    return new _TestMintingGateway(harness, deployment);
+  }
+  get gatewayAddress() {
+    return this.deployment.gatewayAddress;
+  }
+  get argonTokenAddress() {
+    return this.deployment.argonTokenAddress;
+  }
+  get argonotTokenAddress() {
+    return this.deployment.argonotTokenAddress;
+  }
+  async startTransferToArgon(args) {
+    const permitDeadline = (await this.harness.publicClient.getBlock()).timestamp + 3600n;
+    const permitNonce = await this.harness.publicClient.readContract({
+      address: this.argonTokenAddress,
+      abi: argonTokenAbi,
+      functionName: "nonces",
+      args: [args.account.address]
+    });
+    const permitSignature = await signGatewayPermit({
+      account: args.account,
+      chainId: this.harness.chain.id,
+      tokenAddress: this.argonTokenAddress,
+      gatewayAddress: this.gatewayAddress,
+      owner: args.account.address,
+      value: args.amountRuntimeUnits * MINTING_GATEWAY_RUNTIME_TO_ERC20_SCALE,
+      nonce: permitNonce,
+      deadline: permitDeadline
+    });
+    const transactionHash = await createWalletClient3({
+      account: args.account,
+      chain: this.harness.chain,
+      transport: http3(this.harness.endpoints.executionRpcUrl)
+    }).sendTransaction({
+      account: args.account,
+      chain: this.harness.chain,
+      to: this.gatewayAddress,
+      data: encodeFunctionData2({
+        abi: mintingGatewayAbi2,
+        functionName: "startTransferToArgon",
+        args: [
+          this.argonTokenAddress,
+          args.amountRuntimeUnits,
+          args.recipientArgonAddress,
+          permitDeadline,
+          permitSignature.v,
+          permitSignature.r,
+          permitSignature.s
+        ]
       })
     });
+    return waitForExecutionReceipt2(this.harness.ethereum, transactionHash);
   }
-  const port2 = proxyServer.address().port;
-  return `ws://host.docker.internal:${port2}`;
+  async forceUpdateActiveCouncil(replacementCouncil, nextMicrogonsPerArgonot) {
+    return this.harness.publicClient.waitForTransactionReceipt({
+      hash: await this.harness.walletClient.writeContract({
+        account: this.harness.deployer,
+        chain: this.harness.chain,
+        address: this.gatewayAddress,
+        abi: mintingGatewayAbi2,
+        functionName: "forceUpdateActiveCouncil",
+        args: [replacementCouncil, nextMicrogonsPerArgonot]
+      })
+    });
+  }
+  async relayReadyApprovals(batch, operatorAddress) {
+    return this.harness.publicClient.waitForTransactionReceipt({
+      hash: await this.harness.walletClient.writeContract({
+        account: this.harness.deployer,
+        chain: this.harness.chain,
+        address: this.gatewayAddress,
+        abi: mintingGatewayAbi2,
+        functionName: "applyGatewayUpdates",
+        args: [
+          batch.currentCouncil,
+          batch.updates,
+          toHex(decodeAddress(operatorAddress), { size: 32 })
+        ]
+      })
+    });
+  }
+  async argonApprovalsNonce() {
+    return await this.harness.publicClient.readContract({
+      address: this.gatewayAddress,
+      abi: mintingGatewayAbi2,
+      functionName: "argonApprovalsNonce"
+    });
+  }
+  async globalIssuanceCouncil() {
+    return await this.harness.publicClient.readContract({
+      address: this.gatewayAddress,
+      abi: mintingGatewayAbi2,
+      functionName: "globalIssuanceCouncil"
+    });
+  }
+  async authorityCollateral(signingKey) {
+    return await this.harness.publicClient.readContract({
+      address: this.gatewayAddress,
+      abi: mintingGatewayAbi2,
+      functionName: "mintingAuthorityCollateralRemaining",
+      args: [signingKey]
+    });
+  }
+  async finalizeTransferOut(args) {
+    return this.harness.publicClient.waitForTransactionReceipt({
+      hash: await this.harness.walletClient.writeContract({
+        account: this.harness.deployer,
+        chain: this.harness.chain,
+        address: this.gatewayAddress,
+        abi: mintingGatewayAbi2,
+        functionName: "finalizeTransferOutOfArgon",
+        args: [
+          args.transferRequest,
+          {
+            authorizations: [
+              {
+                microgonCollateral: 0n,
+                micronotCollateral: args.micronotCollateral,
+                signature: args.collateralizationSignature
+              }
+            ]
+          }
+        ]
+      })
+    });
+  }
+  async isFinalizedTransferOut(transferRequest) {
+    return await this.harness.publicClient.readContract({
+      address: this.gatewayAddress,
+      abi: mintingGatewayAbi2,
+      functionName: "finalizedTransferOutOfArgonIds",
+      args: [EvmContracts3.hashMintingGatewayTransferOutOfArgonRequest(transferRequest)]
+    });
+  }
+  async argonBalance(address) {
+    return await this.harness.publicClient.readContract({
+      address: this.argonTokenAddress,
+      abi: argonTokenAbi,
+      functionName: "balanceOf",
+      args: [address]
+    });
+  }
+  async fundExecutionAccount(address, value) {
+    return this.harness.publicClient.waitForTransactionReceipt({
+      hash: await this.harness.walletClient.sendTransaction({
+        account: this.harness.deployer,
+        chain: this.harness.chain,
+        to: address,
+        value
+      })
+    });
+  }
+};
+var TestMintingAuthorityActor = class {
+  constructor(harness, args) {
+    this.harness = harness;
+    this.operator = new Keyring3({ type: "sr25519" }).createFromUri(args.operatorUri);
+    this.councilSigner = privateKeyToAccount2(args.councilPrivateKey);
+    this.authoritySigner = privateKeyToAccount2(args.authorityPrivateKey);
+  }
+  operator;
+  councilSigner;
+  authoritySigner;
+  gateway;
+  attachGateway(gateway) {
+    this.gateway = gateway;
+  }
+  async prepareOperator(args) {
+    await this.harness.forceSetBalance(this.operator.address, args.freeBalance);
+    await this.harness.forceSetOwnership(this.operator.address, args.ownershipBalance);
+    const vault = await Vault.create(this.harness.mainchainClient, this.operator, {
+      securitization: 1000000000n,
+      securitizationRatio: 1,
+      annualPercentRate: 0.05,
+      baseFee: 0n,
+      bitcoinXpub: args.bitcoinXpub,
+      treasuryProfitSharing: 0
+    });
+    await vault.getVault();
+    await this.harness.sudoSubmit(
+      this.harness.mainchainClient.tx.priceIndex.setOperator(this.operator.address)
+    );
+    const currentTick = await this.harness.mainchainClient.query.ticks.currentTick();
+    await this.harness.submit(
+      this.harness.mainchainClient.tx.priceIndex.submit({
+        btcUsdPrice: toFixedNumber(6e4, 18),
+        argonotUsdPrice: toFixedNumber(1, 18),
+        argonUsdPrice: toFixedNumber(1, 18),
+        argonUsdTargetPrice: toFixedNumber(1, 18),
+        argonTimeWeightedAverageLiquidity: toFixedNumber(1e6, 18),
+        tick: currentTick.toBigInt()
+      }),
+      this.operator
+    );
+    await this.harness.submit(
+      this.harness.mainchainClient.tx.vaults.setCommittedArgonots(args.committedArgonots),
+      this.operator
+    );
+  }
+  async registerCouncilSigner() {
+    return this.harness.submit(
+      this.harness.mainchainClient.tx.crosschainTransfer.registerCouncilSigner(
+        "Ethereum",
+        this.councilSigner.address,
+        toArgonKeccakSignature(
+          await this.councilSigner.signMessage({
+            message: { raw: toHex(this.registrationMessage("argon/council-signer/v2")) }
+          })
+        )
+      ),
+      this.operator
+    );
+  }
+  async forceSingleMemberCouncil() {
+    await this.harness.sudoSubmit(
+      this.harness.mainchainClient.tx.crosschainTransfer.forceSetGlobalIssuanceCouncil(
+        "Ethereum",
+        0,
+        [this.operator.address]
+      )
+    );
+    const activeCouncilHashOption = await this.harness.mainchainClient.query.crosschainTransfer.activeGlobalIssuanceCouncilByDestinationChain(
+      "Ethereum"
+    );
+    if (activeCouncilHashOption.isNone) {
+      throw new Error("Expected active Ethereum council hash");
+    }
+    const activeCouncilOption = await this.harness.mainchainClient.query.crosschainTransfer.globalIssuanceCouncilByHash(
+      activeCouncilHashOption.unwrap()
+    );
+    if (activeCouncilOption.isNone) {
+      throw new Error("Expected active Ethereum council");
+    }
+    const activeCouncil = activeCouncilOption.unwrap();
+    const currentCouncil = [...activeCouncil.members.entries()].map(([signer, member]) => ({
+      signer: signer.toHex(),
+      weight: member.weight.toBigInt()
+    })).sort((left, right) => left.signer.localeCompare(right.signer));
+    return {
+      activeCouncilHash: activeCouncilHashOption.unwrap().toHex(),
+      activeCouncil,
+      currentCouncil: {
+        signers: currentCouncil.map((member) => member.signer),
+        weights: currentCouncil.map((member) => member.weight)
+      }
+    };
+  }
+  async registerMintingAuthority(micronotCollateral) {
+    return this.harness.submit(
+      this.harness.mainchainClient.tx.crosschainTransfer.registerMintingAuthority(
+        "Ethereum",
+        this.authoritySigner.address,
+        toArgonKeccakSignature(
+          await this.authoritySigner.signMessage({
+            message: {
+              raw: toHex(this.registrationMessage("argon/minting-authority-signer/v2"))
+            }
+          })
+        ),
+        0n,
+        micronotCollateral
+      ),
+      this.operator
+    );
+  }
+  async approveActivationQueueEntry(queueNonce = 1n) {
+    const approvalQueueEntry = await this.harness.mainchainClient.query.crosschainTransfer.councilApprovalQueueByDestinationChainAndNonce(
+      "Ethereum",
+      queueNonce
+    );
+    if (approvalQueueEntry.isNone) {
+      throw new Error(`Expected queue nonce ${queueNonce} to exist`);
+    }
+    const councilApprovalSignature = await this.councilSigner.signMessage({
+      message: {
+        raw: approvalQueueEntry.unwrap().approvalHash.toHex()
+      }
+    });
+    await this.harness.submit(
+      this.harness.mainchainClient.tx.crosschainTransfer.approveQueueEntries(
+        "Ethereum",
+        new Vec(this.harness.mainchainClient.registry, U8aFixed.with(520), [
+          new U8aFixed(
+            this.harness.mainchainClient.registry,
+            toArgonKeccakSignature(councilApprovalSignature),
+            520
+          )
+        ])
+      ),
+      this.operator
+    );
+    const batch = await getReadyEthereumGatewayUpdates(
+      this.harness.mainchainClient,
+      this.harness.publicClient
+    );
+    return {
+      approvalQueueEntry,
+      councilApprovalSignature,
+      batch
+    };
+  }
+  async collateralizeFirstPendingTransferOut() {
+    const gateway = this.requireGateway();
+    const pendingRequests = await this.harness.mainchainClient.query.crosschainTransfer.pendingCollateralizationRequestsByChain(
+      "Ethereum"
+    );
+    if (pendingRequests.length === 0) {
+      throw new Error("Expected a pending collateralization request");
+    }
+    const pendingRequest = pendingRequests[0];
+    const transferId = pendingRequest.transferId.toHex();
+    const transferOption = await this.harness.mainchainClient.query.crosschainTransfer.transferOutById(transferId);
+    if (transferOption.isNone) {
+      throw new Error(`Expected transfer out ${transferId} to exist`);
+    }
+    const transfer = transferOption.unwrap();
+    const transferRequest = {
+      argonAccountId: transfer.argonAccountId.toHex(),
+      argonTransferNonce: transfer.argonTransferNonce.toBigInt(),
+      chainId: BigInt(this.harness.chain.id),
+      microgonsPerArgonot: transfer.microgonsPerArgonot.toBigInt(),
+      recipient: transfer.destinationAccount.toHex(),
+      validUntilBlock: transfer.validUntilEthereumBlock.toBigInt(),
+      token: gateway.argonTokenAddress,
+      amount: transfer.amount.toBigInt(),
+      mintingAuthorityTip: transfer.mintingAuthorityTip.toBigInt()
+    };
+    const micronotCollateral = transfer.amount.toBigInt();
+    const collateralizationHash = EvmContracts3.hashMintingGatewayMintingAuthorization(
+      { chainId: BigInt(this.harness.chain.id), gatewayAddress: gateway.gatewayAddress },
+      {
+        request: transferRequest,
+        microgonCollateral: 0n,
+        micronotCollateral
+      }
+    );
+    const collateralizationSignature = await this.authoritySigner.signMessage({
+      message: {
+        raw: collateralizationHash
+      }
+    });
+    const result = await this.harness.submit(
+      this.harness.mainchainClient.tx.crosschainTransfer.collateralizeTransfer(
+        transferId,
+        toArgonKeccakSignature(collateralizationSignature),
+        0n,
+        micronotCollateral
+      ),
+      this.operator
+    );
+    return {
+      pendingRequest,
+      transferId,
+      transferRequest,
+      micronotCollateral,
+      collateralizationSignature,
+      result
+    };
+  }
+  registrationMessage(prefix) {
+    const prefixBytes = this.harness.mainchainClient.registry.createType("Bytes", prefix).toU8a();
+    const destinationChainBytes = this.harness.mainchainClient.registry.createType("PalletCrosschainTransferSourceChain", "Ethereum").toU8a();
+    const operatorAccountIdBytes = this.harness.mainchainClient.registry.createType("AccountId32", this.operator.address).toU8a();
+    return concatBytes(prefixBytes, destinationChainBytes, operatorAccountIdBytes);
+  }
+  requireGateway() {
+    if (!this.gateway) {
+      throw new Error("Minting authority actor requires an attached TestMintingGateway");
+    }
+    return this.gateway;
+  }
+};
+function concatBytes(...parts) {
+  const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+  const bytes = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of parts) {
+    bytes.set(part, offset);
+    offset += part.length;
+  }
+  return bytes;
 }
+
+// src/index.ts
 function stringifyExt(obj) {
   return JSON.stringify(
     obj,
@@ -1097,54 +2233,12 @@ function stringifyExt(obj) {
     2
   );
 }
-function projectRoot() {
-  if (process4.env.ARGON_PROJECT_ROOT) {
-    return Path7.join(process4.env.ARGON_PROJECT_ROOT);
-  }
-  return Path7.join(__dirname, `../../..`);
-}
-async function runTestScript(relativePath) {
-  const scriptPath = Path7.resolve(projectRoot(), relativePath);
-  return child_process4.execSync(scriptPath, { encoding: "utf8" }).trim();
-}
-async function getDockerPortMapping(containerName, port2) {
-  return child_process4.execSync(`docker port ${containerName} ${port2}`, { 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 runOnTeardown(teardown2) {
-  addTeardown({ teardown: teardown2 });
-}
-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");
+  return new Keyring4({ type: "sr25519" }).createFromUri("//Alice");
 }
 async function activateNotary(sudo2, client, notary) {
   await notary.register(client);
-  const txResult = await new TxSubmitter2(
+  const txResult = await new TxSubmitter4(
     client,
     client.tx.sudo.sudo(client.tx.notaries.activate(notary.operator.publicKey)),
     sudo2
@@ -1152,27 +2246,36 @@ async function activateNotary(sudo2, client, notary) {
   await txResult.waitForInFirstBlock;
 }
 export {
+  EthereumProofE2eHarness,
   SKIP_E2E,
   TestBitcoinCli,
   TestEthereum,
   TestMainchain,
+  TestMintingAuthorityActor,
+  TestMintingGateway,
   TestNotary,
   TestOracle,
   activateNotary,
   addTeardown,
-  argonTokenArtifact,
   cleanHostForDocker,
   closeOnTeardown,
   disconnectOnTeardown,
   getDockerPortMapping,
   getProxy,
-  mintingGatewayArtifact,
+  getReadyEthereumGatewayUpdates,
+  mineLaterExecutionAnchorReceipt,
   projectRoot,
   runOnTeardown,
   runTestScript,
+  signGatewayPermit,
   startNetwork,
   stringifyExt,
   sudo,
-  teardown
+  syncEthereumVerifierUntilAnchorCovers,
+  teardown,
+  toArgonKeccakSignature,
+  toEvmRecoverableSignature,
+  waitForExecutionReceipt2 as waitForExecutionReceipt,
+  waitForFinalizedBeaconExecutionAtOrAbove
 };
 //# sourceMappingURL=index.js.map