@argonprotocol/testing 1.4.3 → 1.4.4

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 http from "http";
-import * as url from "url";
-import * as Path6 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,16 +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 Client from "bitcoin-core";
 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;
@@ -228,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}`);
     }
@@ -237,11 +327,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 +417,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();
@@ -349,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 {
       }
     }
@@ -383,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);
@@ -424,18 +521,63 @@ 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";
-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) {
@@ -447,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";
@@ -467,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}`);
     }
@@ -479,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");
@@ -501,11 +643,475 @@ var TestOracle = class _TestOracle {
   }
 };
 
+// src/TestEthereum.ts
+import * as fs4 from "fs/promises";
+import * as os from "os";
+import * as Path6 from "path";
+import { spawn as spawn4, spawnSync } from "child_process";
+import { detectPort as detectPort2 } from "detect-port";
+import { EvmContracts } from "@argonprotocol/mainchain";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  createPublicClient,
+  createWalletClient,
+  defineChain,
+  encodeFunctionData,
+  getAddress,
+  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;
+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 DEFAULT_INITIAL_MICROGONS_PER_ARGONOT = 1000000n;
+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(Path6.join(os.tmpdir(), "argon-ethereum-devnet-"));
+    const argsFile = Path6.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: http2(executionRpcUrl)
+    });
+    const walletClient = createWalletClient({
+      account,
+      chain,
+      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,
+      bytecode: mintingGatewayArtifact.bytecode,
+      args: [zeroAddress, zeroAddress]
+    });
+    const initializeData = encodeFunctionData({
+      abi: mintingGatewayArtifact.abi,
+      functionName: "initialize",
+      args: [
+        adminSafe,
+        guardianSafe,
+        bootstrapCouncilHash,
+        BigInt(bootstrapCouncil.signers.length),
+        1n,
+        initialMicrogonsPerArgonot
+      ]
+    });
+    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: "migrate",
+          args: [
+            {
+              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 migrate 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 Path7 from "path";
 async function startNetwork(testName, options) {
-  const config = Path5.join(__dirname, `docker-compose.yml`);
+  const config = Path7.join(__dirname, `dev.docker-compose.yml`);
   const env4 = {
     VERSION: "dev",
     ARGON_CHAIN: "dev-docker",
@@ -537,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
-    });
-    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;
+// 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
       }
-      console.log("Proxying http request", queryData.target);
-      proxy?.web(req, res, { target: queryData.target });
+    })
+  );
+  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
     });
-    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
+    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;
+      }
+    } 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,
@@ -598,54 +2233,12 @@ function stringifyExt(obj) {
     2
   );
 }
-function projectRoot() {
-  if (process4.env.ARGON_PROJECT_ROOT) {
-    return Path6.join(process4.env.ARGON_PROJECT_ROOT);
-  }
-  return Path6.join(__dirname, `../../..`);
-}
-async function runTestScript(relativePath) {
-  const scriptPath = Path6.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
@@ -653,9 +2246,13 @@ async function activateNotary(sudo2, client, notary) {
   await txResult.waitForInFirstBlock;
 }
 export {
+  EthereumProofE2eHarness,
   SKIP_E2E,
   TestBitcoinCli,
+  TestEthereum,
   TestMainchain,
+  TestMintingAuthorityActor,
+  TestMintingGateway,
   TestNotary,
   TestOracle,
   activateNotary,
@@ -665,12 +2262,20 @@ export {
   disconnectOnTeardown,
   getDockerPortMapping,
   getProxy,
+  getReadyEthereumGatewayUpdates,
+  mineLaterExecutionAnchorReceipt,
   projectRoot,
   runOnTeardown,
   runTestScript,
+  signGatewayPermit,
   startNetwork,
   stringifyExt,
   sudo,
-  teardown
+  syncEthereumVerifierUntilAnchorCovers,
+  teardown,
+  toArgonKeccakSignature,
+  toEvmRecoverableSignature,
+  waitForExecutionReceipt2 as waitForExecutionReceipt,
+  waitForFinalizedBeaconExecutionAtOrAbove
 };
 //# sourceMappingURL=index.js.map