@argonprotocol/testing 1.4.3-dev.78a9481b → 1.4.3-dev.83602b96

package/lib/index.cjs

@@ -30,9 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  EthereumProofE2eHarness: () => EthereumProofE2eHarness,
   SKIP_E2E: () => SKIP_E2E,
   TestBitcoinCli: () => TestBitcoinCli,
+  TestEthereum: () => TestEthereum,
   TestMainchain: () => TestMainchain,
+  TestMintingAuthorityActor: () => TestMintingAuthorityActor,
+  TestMintingGateway: () => TestMintingGateway,
   TestNotary: () => TestNotary,
   TestOracle: () => TestOracle,
   activateNotary: () => activateNotary,
@@ -42,22 +46,30 @@ __export(index_exports, {
   disconnectOnTeardown: () => disconnectOnTeardown,
   getDockerPortMapping: () => getDockerPortMapping,
   getProxy: () => getProxy,
+  getReadyEthereumGatewayUpdates: () => getReadyEthereumGatewayUpdates,
+  mineLaterExecutionAnchorReceipt: () => mineLaterExecutionAnchorReceipt,
   projectRoot: () => projectRoot,
   runOnTeardown: () => runOnTeardown,
   runTestScript: () => runTestScript,
+  signGatewayPermit: () => signGatewayPermit,
   startNetwork: () => startNetwork,
   stringifyExt: () => stringifyExt,
   sudo: () => sudo,
-  teardown: () => teardown
+  syncEthereumVerifierUntilAnchorCovers: () => syncEthereumVerifierUntilAnchorCovers,
+  teardown: () => teardown,
+  toArgonKeccakSignature: () => toArgonKeccakSignature,
+  toEvmRecoverableSignature: () => toEvmRecoverableSignature,
+  waitForExecutionReceipt: () => waitForExecutionReceipt2,
+  waitForFinalizedBeaconExecutionAtOrAbove: () => waitForFinalizedBeaconExecutionAtOrAbove
 });
 module.exports = __toCommonJS(index_exports);
-var import_mainchain4 = require("@argonprotocol/mainchain");
+var import_mainchain8 = require("@argonprotocol/mainchain");
 var process4 = __toESM(require("process"), 1);
 var import_http_proxy = __toESM(require("http-proxy"), 1);
 var child_process4 = __toESM(require("child_process"), 1);
-var http = __toESM(require("http"), 1);
+var http3 = __toESM(require("http"), 1);
 var url = __toESM(require("url"), 1);
-var Path6 = __toESM(require("path"), 1);
+var Path7 = __toESM(require("path"), 1);
 
 // src/TestNotary.ts
 var import_nanoid = require("nanoid");
@@ -246,7 +258,6 @@ var Path2 = __toESM(require("path"), 1);
 var readline2 = __toESM(require("readline"), 1);
 var import_detect_port = require("detect-port");
 var import_nanoid2 = require("nanoid");
-var import_bitcoin_core = __toESM(require("bitcoin-core"), 1);
 var lockfile = __toESM(require("proper-lockfile"), 1);
 var import_mainchain2 = require("@argonprotocol/mainchain");
 var nanoid2 = (0, import_nanoid2.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyz", 4);
@@ -282,11 +293,7 @@ var TestMainchain = class {
     addTeardown(this);
   }
   getBitcoinClient() {
-    return new import_bitcoin_core.default({
-      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
@@ -376,9 +383,20 @@ var TestMainchain = class {
     return this.address;
   }
   async client() {
-    const client = await (0, import_mainchain2.getClient)(this.address);
-    disconnectOnTeardown(client);
-    return client;
+    let lastError;
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      try {
+        const client = await (0, import_mainchain2.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();
@@ -469,6 +487,51 @@ var TestMainchain = class {
     return cleanHostForDocker(`http://bitcoin:bitcoin@localhost:${rpcPort}`);
   }
 };
+var BitcoinRpcClient = class {
+  #rpcUrl;
+  #authorization;
+  constructor(rpcUrl, username, password) {
+    this.#rpcUrl = rpcUrl;
+    this.#authorization = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+  }
+  async command(method, ...params) {
+    const response = await fetch(this.#rpcUrl, {
+      method: "POST",
+      headers: {
+        authorization: this.#authorization,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "1.0",
+        id: `${method}-${Date.now()}`,
+        method,
+        params
+      })
+    });
+    const body = await response.text();
+    let payload;
+    if (body) {
+      try {
+        payload = JSON.parse(body);
+      } catch {
+        payload = void 0;
+      }
+    }
+    if (payload?.error) {
+      const httpStatus = response.ok ? "" : ` with HTTP ${response.status}`;
+      throw new Error(
+        `Bitcoin RPC ${method} failed${httpStatus} (${payload.error.code}): ${payload.error.message}`
+      );
+    }
+    if (!response.ok) {
+      throw new Error(`Bitcoin RPC ${method} failed with HTTP ${response.status}`);
+    }
+    if (!payload) {
+      throw new Error(`Bitcoin RPC ${method} returned an invalid JSON response`);
+    }
+    return payload.result;
+  }
+};
 
 // src/TestBitcoinCli.ts
 var child_process2 = __toESM(require("child_process"), 1);
@@ -546,11 +609,467 @@ var TestOracle = class _TestOracle {
   }
 };
 
+// src/TestEthereum.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var os = __toESM(require("os"), 1);
+var Path5 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
+var import_detect_port2 = require("detect-port");
+var import_mainchain4 = require("@argonprotocol/mainchain");
+var import_accounts = require("viem/accounts");
+var import_viem = require("viem");
+var {
+  argonTokenArtifact,
+  argonotTokenArtifact,
+  hashMintingGatewayGlobalIssuanceCouncil,
+  mintingGatewayArtifact,
+  proxyAdminArtifact,
+  transparentUpgradeableProxyArtifact
+} = import_mainchain4.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 (0, import_node_child_process2.spawnSync)(kurtosisBin, ["version"], { stdio: "ignore" }).status === 0;
+  }
+  async launch(options) {
+    const {
+      consensusClient = "lighthouse",
+      preset = "mainnet",
+      secondsPerSlot,
+      waitForFinalization = true,
+      prefundedAccounts
+    } = options ?? {};
+    const elPublicPortStart = await findFreePortRange(DEFAULT_EL_PORT_START, PORT_RANGE_SIZE);
+    const clPublicPortStart = await findFreePortRange(DEFAULT_CL_PORT_START, PORT_RANGE_SIZE);
+    this.#argsDir = await fs4.mkdtemp(Path5.join(os.tmpdir(), "argon-ethereum-devnet-"));
+    const argsFile = Path5.join(this.#argsDir, "network-params.yaml");
+    await fs4.writeFile(
+      argsFile,
+      renderEthereumArgs(
+        elPublicPortStart,
+        clPublicPortStart,
+        consensusClient,
+        preset,
+        secondsPerSlot,
+        waitForFinalization,
+        prefundedAccounts
+      )
+    );
+    await runCommand(
+      this.kurtosisBin,
+      ["run", "--enclave", this.enclaveName, this.packageRef, "--args-file", argsFile],
+      KURTOSIS_RUN_TIMEOUT_MS
+    );
+    const executionRpc = await waitForProbe(
+      () => findExecutionRpcUrl(elPublicPortStart, PORT_RANGE_SIZE),
+      PROBE_TIMEOUT_MS
+    );
+    const beaconApi = await waitForProbe(
+      () => findBeaconApiUrl(clPublicPortStart, PORT_RANGE_SIZE),
+      PROBE_TIMEOUT_MS
+    );
+    this.executionRpcUrl = executionRpc.url;
+    this.beaconApiUrl = beaconApi.url;
+    this.chainId = executionRpc.chainId;
+    await waitForProbe(
+      () => this.getBeacon("/eth/v1/beacon/genesis"),
+      LIGHT_CLIENT_READY_TIMEOUT_MS
+    );
+    return {
+      executionRpcUrl: this.executionRpcUrl,
+      beaconApiUrl: this.beaconApiUrl,
+      chainId: this.chainId
+    };
+  }
+  async callExecution(method, params = []) {
+    const executionRpcUrl = this.executionRpcUrl;
+    if (!executionRpcUrl) {
+      throw new Error("Execution RPC URL is not available before launch");
+    }
+    const response = await fetch(executionRpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method,
+        params
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Execution RPC request failed for ${method}: ${response.status}`);
+    }
+    const body = await response.json();
+    if (body.error) {
+      throw new Error(
+        `Execution RPC ${method} failed (${body.error.code ?? "unknown"}): ${body.error.message ?? "unknown error"}`
+      );
+    }
+    return body.result;
+  }
+  async getBeacon(path) {
+    const beaconApiUrl = this.beaconApiUrl;
+    if (!beaconApiUrl) {
+      throw new Error("Beacon API URL is not available before launch");
+    }
+    const response = await fetch(new URL(path, `${beaconApiUrl}/`), {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Beacon API request failed for ${path}: ${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 = (0, import_accounts.privateKeyToAccount)(options.deployerPrivateKey);
+    const adminSafe = options.adminSafe ?? account.address;
+    const guardianSafe = options.guardianSafe ?? adminSafe;
+    const chain = createExecutionChain(chainId, executionRpcUrl);
+    const publicClient = (0, import_viem.createPublicClient)({
+      chain,
+      transport: (0, import_viem.http)(executionRpcUrl)
+    });
+    const walletClient = (0, import_viem.createWalletClient)({
+      account,
+      chain,
+      transport: (0, import_viem.http)(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: [import_viem.zeroAddress, import_viem.zeroAddress]
+    });
+    const initializeData = (0, import_viem.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: (0, import_viem.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: (0, import_viem.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 (0, import_viem.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 (0, import_viem.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) => (0, import_detect_port2.detectPort)(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 = (0, import_node_child_process2.spawn)(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
 var docker = __toESM(require("docker-compose"), 1);
-var Path5 = __toESM(require("path"), 1);
+var Path6 = __toESM(require("path"), 1);
 async function startNetwork(testName, options) {
-  const config = Path5.join(__dirname, `dev.docker-compose.yml`);
+  const config = Path6.join(__dirname, `dev.docker-compose.yml`);
   const env4 = {
     VERSION: "dev",
     ARGON_CHAIN: "dev-docker",
@@ -582,6 +1101,961 @@ async function startNetwork(testName, options) {
   };
 }
 
+// src/EthereumE2eUtils.ts
+var import_mainchain5 = require("@argonprotocol/mainchain");
+var import_viem2 = require("viem");
+async function signGatewayPermit(args) {
+  const signature = (0, import_viem2.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
+    });
+    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 (0, import_mainchain5.getLatestArgonFinalizedExecutionHeader)(mainchainClient);
+      lastAnchorBlockNumber = anchor.blockNumber;
+      if (anchor.blockNumber >= minimumExecutionBlockNumber) {
+        return;
+      }
+    } catch {
+    }
+    const txs = await (0, import_mainchain5.getNextEthereumBeaconSyncTxs)(mainchainClient, beaconApiUrl);
+    if (txs.length === 0) {
+      await delay2(500);
+      continue;
+    }
+    let shouldRetry = false;
+    for (const tx of txs) {
+      try {
+        const result = await new import_mainchain5.TxSubmitter(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 = (0, import_mainchain5.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 (0, import_mainchain5.u8aToHex)(bytes);
+}
+function toEvmRecoverableSignature(signature) {
+  const bytes = (0, import_mainchain5.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 (0, import_mainchain5.u8aToHex)(bytes);
+}
+function isRetryableEthereumVerifierSyncError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return (0, import_mainchain5.isOutdatedTransactionError)(error) || message.includes("ethereumVerifier.InvalidHeaderMerkleProof");
+}
+async function delay2(ms) {
+  await new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/EthereumGatewayQueue.ts
+var import_mainchain6 = require("@argonprotocol/mainchain");
+var import_viem3 = require("viem");
+var {
+  encodeMintingGatewayMintingAuthorityActivationTarget,
+  hashMintingGatewayActivateMintingAuthority,
+  hashMintingGatewayGatewayUpdateApproval,
+  mintingGatewayAbi,
+  MINTING_GATEWAY_UPDATE_KINDS
+} = import_mainchain6.EvmContracts;
+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 = (0, import_viem3.getAddress)(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 updates = [];
+  let expectedPreviousApprovalHash = argonApprovalsHash;
+  let firstQueueNonce;
+  let lastQueueNonce;
+  if (!paused) {
+    for (let queueNonce = argonApprovalsNonce + 1n; updates.length < 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);
+      const approvingCouncil = await loadCouncilByHash(client, approvingCouncilHash, councilCache);
+      if (!queueEntryHasQuorum(entry, approvingCouncil)) {
+        break;
+      }
+      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
+      });
+      updates.push(update);
+      firstQueueNonce ??= queueNonce;
+      lastQueueNonce = queueNonce;
+      expectedPreviousApprovalHash = toHexValue(entry.approvalHash);
+    }
+  }
+  return {
+    destinationChain,
+    chainId,
+    gatewayAddress,
+    currentCouncilHash,
+    currentCouncil,
+    argonApprovalsNonce,
+    argonApprovalsHash,
+    paused,
+    ...firstQueueNonce !== void 0 ? { firstQueueNonce, lastQueueNonce } : {},
+    updates
+  };
+}
+async function buildGatewayUpdate(client, destinationChain, hashContext, queueNonce, queueItem) {
+  const { entry, approvingCouncilHash } = queueItem;
+  const signatures = getSortedSignatures(entry.signatures);
+  if (entry.target.isMintingAuthorityActivation) {
+    const signingKey = (0, import_viem3.getAddress)(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)
+    });
+    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
+    };
+  }
+  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: (0, import_viem3.getAddress)(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, signature]) => {
+    const signerAddress = (0, import_viem3.getAddress)(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;
+}
+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 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
+var import_mainchain7 = require("@argonprotocol/mainchain");
+var import_accounts2 = require("viem/accounts");
+var import_viem4 = require("viem");
+var { argonTokenAbi, mintingGatewayAbi: mintingGatewayAbi2, MINTING_GATEWAY_RUNTIME_TO_ERC20_SCALE } = import_mainchain7.EvmContracts;
+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 = (0, import_accounts2.privateKeyToAccount)(deployerPrivateKey);
+    this.chain = (0, import_viem4.defineChain)({
+      id: Number.parseInt(endpoints.chainId, 16),
+      name: "argon-test-ethereum",
+      nativeCurrency: {
+        name: "Ether",
+        symbol: "ETH",
+        decimals: 18
+      },
+      rpcUrls: {
+        default: {
+          http: [endpoints.executionRpcUrl]
+        }
+      }
+    });
+    this.publicClient = (0, import_viem4.createPublicClient)({
+      chain: this.chain,
+      transport: (0, import_viem4.http)(endpoints.executionRpcUrl)
+    });
+    this.walletClient = (0, import_viem4.createWalletClient)({
+      account: this.deployer,
+      chain: this.chain,
+      transport: (0, import_viem4.http)(endpoints.executionRpcUrl)
+    });
+    this.proofRelayer = new import_mainchain7.Keyring({ type: "sr25519" }).createFromUri(proofRelayerUri);
+  }
+  sudoSigner = new import_mainchain7.Keyring({ 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 import_mainchain7.TxSubmitter(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: ${(0, import_mainchain7.dispatchErrorToString)(this.mainchainClient, sudoResult.asErr)}`
+      );
+    }
+    return result;
+  }
+  async bootstrapVerifier() {
+    const checkpointTx = await (0, import_mainchain7.getEthereumBeaconSyncBootstrapTx)(
+      this.mainchainClient,
+      this.endpoints.beaconApiUrl
+    );
+    return this.sudoSubmit(checkpointTx);
+  }
+  async syncVerifierThrough(minimumExecutionBlockNumber) {
+    await syncEthereumVerifierUntilAnchorCovers(
+      this.mainchainClient,
+      this.sudoSigner,
+      this.endpoints.beaconApiUrl,
+      minimumExecutionBlockNumber
+    );
+  }
+  async proveGatewayActivity(gatewayAddress, throughExecutionBlockNumber) {
+    const payload = await (0, import_mainchain7.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 setEthereumChainConfig(gateway) {
+    return this.sudoSubmit(
+      this.mainchainClient.tx.crosschainTransfer.setChainConfig("Ethereum", {
+        Evm: {
+          chainId: this.chain.id,
+          gateway: gateway.gatewayAddress,
+          argonToken: gateway.argonTokenAddress,
+          argonotToken: gateway.argonotTokenAddress
+        }
+      })
+    );
+  }
+  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 (0, import_viem4.createWalletClient)({
+      account: args.account,
+      chain: this.harness.chain,
+      transport: (0, import_viem4.http)(this.harness.endpoints.executionRpcUrl)
+    }).sendTransaction({
+      account: args.account,
+      chain: this.harness.chain,
+      to: this.gatewayAddress,
+      data: (0, import_viem4.encodeFunctionData)({
+        abi: mintingGatewayAbi2,
+        functionName: "startTransferToArgon",
+        args: [
+          this.argonTokenAddress,
+          args.amountRuntimeUnits,
+          args.recipientArgonAddress,
+          permitDeadline,
+          permitSignature.v,
+          permitSignature.r,
+          permitSignature.s
+        ]
+      })
+    });
+    return waitForExecutionReceipt2(this.harness.ethereum, transactionHash);
+  }
+  async forceUpdateActiveCouncil(currentCouncil) {
+    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: [currentCouncil]
+      })
+    });
+  }
+  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,
+          (0, import_viem4.toHex)((0, import_mainchain7.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: [import_mainchain7.EvmContracts.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 import_mainchain7.Keyring({ type: "sr25519" }).createFromUri(args.operatorUri);
+    this.councilSigner = (0, import_accounts2.privateKeyToAccount)(args.councilPrivateKey);
+    this.authoritySigner = (0, import_accounts2.privateKeyToAccount)(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 import_mainchain7.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: (0, import_mainchain7.toFixedNumber)(6e4, 18),
+        argonotUsdPrice: (0, import_mainchain7.toFixedNumber)(1, 18),
+        argonUsdPrice: (0, import_mainchain7.toFixedNumber)(1, 18),
+        argonUsdTargetPrice: (0, import_mainchain7.toFixedNumber)(1, 18),
+        argonTimeWeightedAverageLiquidity: (0, import_mainchain7.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: (0, import_viem4.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 setMinimumValue(value) {
+    return this.harness.sudoSubmit(
+      this.harness.mainchainClient.tx.crosschainTransfer.setMinimumMintingAuthorityValue(
+        "Ethereum",
+        value
+      )
+    );
+  }
+  async registerMintingAuthority(micronotCollateral) {
+    return this.harness.submit(
+      this.harness.mainchainClient.tx.crosschainTransfer.registerMintingAuthority(
+        "Ethereum",
+        this.authoritySigner.address,
+        toArgonKeccakSignature(
+          await this.authoritySigner.signMessage({
+            message: {
+              raw: (0, import_viem4.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 import_mainchain7.Vec(this.harness.mainchainClient.registry, import_mainchain7.U8aFixed.with(520), [
+          new import_mainchain7.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),
+      councilHash: transfer.councilHash.toHex(),
+      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 = import_mainchain7.EvmContracts.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
 var toTeardown = [];
 var proxy = null;
@@ -595,7 +2069,7 @@ async function getProxy() {
       autoRewrite: true
     });
     proxy.on("error", () => null);
-    proxyServer = http.createServer(function(req, res) {
+    proxyServer = http3.createServer(function(req, res) {
       const queryData = url.parse(req.url, true).query;
       if (!queryData.target) {
         res.writeHead(500, { "Content-Type": "text/plain" });
@@ -645,12 +2119,12 @@ function stringifyExt(obj) {
 }
 function projectRoot() {
   if (process4.env.ARGON_PROJECT_ROOT) {
-    return Path6.join(process4.env.ARGON_PROJECT_ROOT);
+    return Path7.join(process4.env.ARGON_PROJECT_ROOT);
   }
-  return Path6.join(__dirname, `../../..`);
+  return Path7.join(__dirname, `../../..`);
 }
 async function runTestScript(relativePath) {
-  const scriptPath = Path6.resolve(projectRoot(), relativePath);
+  const scriptPath = Path7.resolve(projectRoot(), relativePath);
   return child_process4.execSync(scriptPath, { encoding: "utf8" }).trim();
 }
 async function getDockerPortMapping(containerName, port2) {
@@ -686,11 +2160,11 @@ function disconnectOnTeardown(closeable) {
   return closeable;
 }
 function sudo() {
-  return new import_mainchain4.Keyring({ type: "sr25519" }).createFromUri("//Alice");
+  return new import_mainchain8.Keyring({ type: "sr25519" }).createFromUri("//Alice");
 }
 async function activateNotary(sudo2, client, notary) {
   await notary.register(client);
-  const txResult = await new import_mainchain4.TxSubmitter(
+  const txResult = await new import_mainchain8.TxSubmitter(
     client,
     client.tx.sudo.sudo(client.tx.notaries.activate(notary.operator.publicKey)),
     sudo2
@@ -699,9 +2173,13 @@ async function activateNotary(sudo2, client, notary) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EthereumProofE2eHarness,
   SKIP_E2E,
   TestBitcoinCli,
+  TestEthereum,
   TestMainchain,
+  TestMintingAuthorityActor,
+  TestMintingGateway,
   TestNotary,
   TestOracle,
   activateNotary,
@@ -711,12 +2189,20 @@ async function activateNotary(sudo2, client, notary) {
   disconnectOnTeardown,
   getDockerPortMapping,
   getProxy,
+  getReadyEthereumGatewayUpdates,
+  mineLaterExecutionAnchorReceipt,
   projectRoot,
   runOnTeardown,
   runTestScript,
+  signGatewayPermit,
   startNetwork,
   stringifyExt,
   sudo,
-  teardown
+  syncEthereumVerifierUntilAnchorCovers,
+  teardown,
+  toArgonKeccakSignature,
+  toEvmRecoverableSignature,
+  waitForExecutionReceipt,
+  waitForFinalizedBeaconExecutionAtOrAbove
 });
 //# sourceMappingURL=index.cjs.map