@recoillink/cli 0.0.0-stage → 45.0.1

package/bundle/628.index.js

@@ -0,0 +1,152 @@
+export const id = 628;
+export const ids = [628];
+export const modules = {
+
+/***/ 12628:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ZKSyncDeployer: () => (/* binding */ ZKSyncDeployer)
+/* harmony export */ });
+/* harmony import */ var ethers__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(62418);
+/* harmony import */ var zksync_ethers__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31671);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16639);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(21387);
+/* harmony import */ var _providers_builders_zksync_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(43597);
+/* harmony import */ var _utils_zksync_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(68927);
+
+
+
+
+
+// Local zksync in-memory test node (era-test-node) defaults: chainId 260 on
+// port 8011. Used when a ZKSyncDeployer is constructed without a
+// provider-backed wallet.
+const LOCAL_ZKSYNC_TEST_NODE = {
+    name: 'localZkSyncTestNode',
+    protocol: _recoillink_utils__WEBPACK_IMPORTED_MODULE_1__/* .ProtocolType */ .Hb.Ethereum,
+    chainId: 260,
+    domainId: 260,
+    rpcUrls: [{ http: 'http://127.0.0.1:8011' }],
+};
+/**
+ * Class for deploying contracts to the ZKSync network.
+ */
+class ZKSyncDeployer {
+    zkWallet;
+    deploymentType;
+    constructor(zkWallet, deploymentType) {
+        this.deploymentType = deploymentType;
+        this.zkWallet = zkWallet.connect(zkWallet.provider ?? (0,_providers_builders_zksync_js__WEBPACK_IMPORTED_MODULE_2__/* .defaultZKProviderBuilder */ .T)(LOCAL_ZKSYNC_TEST_NODE));
+    }
+    /**
+     * Loads and validates a ZKSync contract artifact by name
+     * @param contractTitle - Contract name or qualified name (sourceName:contractName)
+     *
+     * @returns The ZKSync artifact
+     */
+    async loadArtifact(contractTitle) {
+        const artifact = await (0,_utils_zksync_js__WEBPACK_IMPORTED_MODULE_3__/* .getZKSyncArtifactByContractName */ .z)(contractTitle);
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_4__/* .assert */ .v)(artifact, `No ZKSync artifact for contract ${contractTitle} found!`);
+        return artifact;
+    }
+    /**
+     * Estimates the price of calling a deploy transaction in ETH.
+     *
+     * @param artifact The previously loaded artifact object.
+     * @param constructorArguments List of arguments to be passed to the contract constructor.
+     *
+     * @returns Calculated fee in ETH wei
+     */
+    async estimateDeployFee(artifact, constructorArguments) {
+        const gas = await this.estimateDeployGas(artifact, constructorArguments);
+        const gasPrice = await this.zkWallet.provider.getGasPrice();
+        return gas.mul(gasPrice);
+    }
+    /**
+     * Estimates the amount of gas needed to execute a deploy transaction.
+     *
+     * @param artifact The previously loaded artifact object.
+     * @param constructorArguments List of arguments to be passed to the contract constructor.
+     *
+     * @returns Calculated amount of gas.
+     */
+    async estimateDeployGas(artifact, constructorArguments) {
+        const factoryDeps = await this.extractFactoryDeps(artifact);
+        const factory = new zksync_ethers__WEBPACK_IMPORTED_MODULE_0__.ContractFactory(artifact.abi, artifact.bytecode, this.zkWallet, this.deploymentType);
+        // Encode deploy transaction so it can be estimated.
+        const deployTx = factory.getDeployTransaction(...constructorArguments, {
+            customData: {
+                factoryDeps,
+            },
+        });
+        deployTx.from = this.zkWallet.address;
+        return this.zkWallet.provider.estimateGas(deployTx);
+    }
+    /**
+     * Sends a deploy transaction to the zkSync network.
+     * For now, it will use defaults for the transaction parameters:
+     * - fee amount is requested automatically from the zkSync server.
+     *
+     * @param artifact The previously loaded artifact object.
+     * @param constructorArguments List of arguments to be passed to the contract constructor.
+     * @param overrides Optional object with additional deploy transaction parameters.
+     * @param additionalFactoryDeps Additional contract bytecodes to be added to the factory dependencies list.
+     *
+     * @returns A contract object.
+     */
+    async deploy(artifact, constructorArguments = [], overrides, additionalFactoryDeps) {
+        const baseDeps = await this.extractFactoryDeps(artifact);
+        const additionalDeps = additionalFactoryDeps
+            ? additionalFactoryDeps.map((val) => ethers__WEBPACK_IMPORTED_MODULE_5__.utils.hexlify(val))
+            : [];
+        const factoryDeps = [...baseDeps, ...additionalDeps];
+        const factory = new zksync_ethers__WEBPACK_IMPORTED_MODULE_0__.ContractFactory(artifact.abi, artifact.bytecode, this.zkWallet, this.deploymentType);
+        const { customData, ..._overrides } = overrides ?? {};
+        // Encode and send the deploy transaction providing factory dependencies.
+        const contract = await factory.deploy(...constructorArguments, {
+            ..._overrides,
+            customData: {
+                ...customData,
+                factoryDeps,
+            },
+        });
+        await contract.deployed();
+        return contract;
+    }
+    /**
+     * Extracts factory dependencies from the artifact.
+     *
+     * @param artifact Artifact to extract dependencies from
+     *
+     * @returns Factory dependencies in the format expected by SDK.
+     */
+    async extractFactoryDeps(artifact) {
+        const visited = new Set();
+        visited.add(`${artifact.sourceName}:${artifact.contractName}`);
+        return this.extractFactoryDepsRecursive(artifact, visited);
+    }
+    async extractFactoryDepsRecursive(artifact, visited) {
+        // Load all the dependency bytecodes.
+        // We transform it into an array of bytecodes.
+        const factoryDeps = [];
+        for (const dependencyHash in artifact.factoryDeps) {
+            if (Object.prototype.hasOwnProperty.call(artifact.factoryDeps, dependencyHash)) {
+                const dependencyContract = artifact.factoryDeps[dependencyHash];
+                if (!visited.has(dependencyContract)) {
+                    const dependencyArtifact = await this.loadArtifact(dependencyContract);
+                    factoryDeps.push(dependencyArtifact.bytecode);
+                    visited.add(dependencyContract);
+                    const transitiveDeps = await this.extractFactoryDepsRecursive(dependencyArtifact, visited);
+                    factoryDeps.push(...transitiveDeps);
+                }
+            }
+        }
+        return factoryDeps;
+    }
+}
+//# sourceMappingURL=ZKSyncDeployer.js.map
+
+/***/ })
+
+};

package/bundle/633.index.js

@@ -0,0 +1,86 @@
+export const id = 633;
+export const ids = [633];
+export const modules = {
+
+/***/ 70633:
+/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Address: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.pV),
+/* harmony export */   Authorization: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.yR),
+/* harmony export */   BHP1024: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.g4),
+/* harmony export */   BHP256: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.I_),
+/* harmony export */   BHP512: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.$g),
+/* harmony export */   BHP768: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.wl),
+/* harmony export */   Boolean: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.v8),
+/* harmony export */   CallbackQuery: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Mm),
+/* harmony export */   Ciphertext: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.z$),
+/* harmony export */   ComputeKey: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Ji),
+/* harmony export */   DynamicRecord: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.xN),
+/* harmony export */   EncryptionToolkit: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.AU),
+/* harmony export */   Execution: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Zc),
+/* harmony export */   ExecutionRequest: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.US),
+/* harmony export */   ExecutionResponse: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.qp),
+/* harmony export */   Field: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.D0),
+/* harmony export */   GraphKey: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.cm),
+/* harmony export */   Group: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.YJ),
+/* harmony export */   I128: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.tE),
+/* harmony export */   I16: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.pt),
+/* harmony export */   I32: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.jP),
+/* harmony export */   I64: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.uv),
+/* harmony export */   I8: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.I8),
+/* harmony export */   Metadata: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.OS),
+/* harmony export */   OfflineQuery: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.c7),
+/* harmony export */   Pedersen128: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.YS),
+/* harmony export */   Pedersen64: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.L0),
+/* harmony export */   Plaintext: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.wN),
+/* harmony export */   Poseidon2: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.EC),
+/* harmony export */   Poseidon4: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.ER),
+/* harmony export */   Poseidon8: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.En),
+/* harmony export */   PrivateKey: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.ZD),
+/* harmony export */   PrivateKeyCiphertext: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.LW),
+/* harmony export */   Program: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.BP),
+/* harmony export */   ProgramImportsBuilder: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Jb),
+/* harmony export */   ProgramManager: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Ao),
+/* harmony export */   Proof: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Ri),
+/* harmony export */   ProvingKey: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.$7),
+/* harmony export */   ProvingRequest: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.rG),
+/* harmony export */   QueryOption: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.wU),
+/* harmony export */   RecordCiphertext: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.KC),
+/* harmony export */   RecordPlaintext: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.ZF),
+/* harmony export */   Scalar: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.X5),
+/* harmony export */   Signature: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.to),
+/* harmony export */   Transaction: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.ZX),
+/* harmony export */   Transition: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.eB),
+/* harmony export */   U128: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.xQ),
+/* harmony export */   U16: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.R7),
+/* harmony export */   U32: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.vD),
+/* harmony export */   U64: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Em),
+/* harmony export */   U8: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.U8),
+/* harmony export */   Value: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.WT),
+/* harmony export */   VerifyingKey: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.pF),
+/* harmony export */   ViewKey: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.hv),
+/* harmony export */   getMaxProgramImports: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.zF),
+/* harmony export */   getOrInitConsensusVersionTestHeights: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.vy),
+/* harmony export */   initThreadPool: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Fs),
+/* harmony export */   setWasmLogLevel: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.zW),
+/* harmony export */   snarkVerify: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.n1),
+/* harmony export */   snarkVerifyBatch: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.LC),
+/* harmony export */   stringToField: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.zK),
+/* harmony export */   verifyFunctionExecution: () => (/* reexport safe */ _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__.Yc)
+/* harmony export */ });
+/* harmony import */ var _provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(64446);
+var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__]);
+_provablehq_wasm_testnet_js__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+
+
+//# sourceMappingURL=wasm-DM2k_rDG.js.map
+
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } });
+
+/***/ })
+
+};

package/bundle/697.index.js

@@ -0,0 +1,410 @@
+export const id = 697;
+export const ids = [697];
+export const modules = {
+
+/***/ 73697:
+/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   createEvmForkManagerFactory: () => (/* binding */ createEvmForkManagerFactory)
+/* harmony export */ });
+/* unused harmony exports getAnvilCommand, waitForEvmRpcReady, EvmForkManager */
+/* harmony import */ var _ethersproject_providers__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(75024);
+/* harmony import */ var ethers__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(98396);
+/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(30025);
+/* harmony import */ var node_net__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(77030);
+/* harmony import */ var _recoillink_forking_sdk__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(65310);
+/* harmony import */ var _recoillink_sdk__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(17023);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14918);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(21387);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(26400);
+/* harmony import */ var _logger_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(54321);
+
+
+
+
+
+
+
+
+const LOCAL_HOST = 'http://127.0.0.1';
+// Per-probe RPC timeout so a single hung request fails fast and the bounded
+// readiness loop can continue.
+const RPC_PROBE_TIMEOUT_MS = 5000;
+class RunningEvmFork {
+    provider;
+    endpoint;
+    kill;
+    constructor(provider, endpoint, kill) {
+        this.provider = provider;
+        this.endpoint = endpoint;
+        this.kill = kill;
+    }
+}
+// The registry currently marks Arc's technicalStack as "other". Match its
+// canonical name and known network IDs so custom metadata names also work.
+const ARC_CHAIN_NAMES = new Set(['arc', 'arctestnet']);
+const ARC_CHAIN_IDS = new Set(['5042', '5042002']);
+function isArcChain(chainName, chainId) {
+    return ARC_CHAIN_NAMES.has(chainName) || ARC_CHAIN_IDS.has(String(chainId));
+}
+function getAnvilCommand(config) {
+    const isArc = isArcChain(config.chainName, config.chainId);
+    return {
+        binary: isArc ? 'arc-anvil' : 'anvil',
+        args: [
+            '--port',
+            String(config.port),
+            '--chain-id',
+            String(config.chainId),
+            '--fork-url',
+            config.upstreamRpcUrl,
+            // Arc derives its block gas limit from protocol configuration and rejects
+            // this flag. Keep the existing behavior for other EVM chains.
+            ...(!isArc ? ['--disable-block-gas-limit'] : []),
+        ],
+    };
+}
+function defaultSpawnAnvil(config) {
+    const { binary, args } = getAnvilCommand(config);
+    return (0,execa__WEBPACK_IMPORTED_MODULE_2__/* .execa */ .Ho)(binary, args);
+}
+/**
+ * execa renders the full Anvil command — including the credential-bearing
+ * `--fork-url` argument — into its error's message/command fields, and shell-
+ * quotes it, so a URL containing a quote survives an exact-string strip. We
+ * therefore surface a fixed error derived from none of execa's rendered-command
+ * fields, copying only non-command diagnostics so failures stay debuggable.
+ * Anvil has no env option for `--fork-url`, so the URL stays in argv (visible to
+ * a local-machine `ps` only); this keeps it out of every error we log or rethrow.
+ */
+class AnvilStartError extends Error {
+    exitCode;
+    signal;
+    signalDescription;
+    code;
+    constructor(binary, missingBinary) {
+        super(missingBinary && binary === 'arc-anvil'
+            ? 'arc-anvil not found on PATH; install Arc Foundry from https://github.com/circlefin/arc-foundry'
+            : `${binary} failed to start`);
+        this.name = 'AnvilStartError';
+    }
+}
+function sanitizeAnvilError(error, config) {
+    const binary = getAnvilCommand(config).binary;
+    const missingBinary = typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT';
+    const sanitized = new AnvilStartError(binary, missingBinary);
+    if (typeof error === 'object' && error !== null) {
+        if ('exitCode' in error)
+            sanitized.exitCode = error.exitCode;
+        if ('signal' in error)
+            sanitized.signal = error.signal;
+        if ('signalDescription' in error) {
+            sanitized.signalDescription = error.signalDescription;
+        }
+        if ('code' in error)
+            sanitized.code = error.code;
+    }
+    return sanitized;
+}
+async function waitForEvmRpcReady(provider, signal, chainName, chainId) {
+    await (0,_recoillink_forking_sdk__WEBPACK_IMPORTED_MODULE_1__/* .waitUntilReady */ .bs)(() => (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_3__/* .timeout */ .wR)(provider.getNetwork(), RPC_PROBE_TIMEOUT_MS, 'anvil readiness probe timed out'), { attempts: 10, baseRetryMs: 500, signal });
+    if (isArcChain(chainName, chainId)) {
+        const nodeInfo = await (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_3__/* .timeout */ .wR)(provider.send('anvil_nodeInfo', []), RPC_PROBE_TIMEOUT_MS, 'Arc Anvil mode probe timed out');
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_4__/* .assert */ .v)(typeof nodeInfo === 'object' &&
+            nodeInfo !== null &&
+            'network' in nodeInfo &&
+            nodeInfo.network === 'arc', 'Arc Anvil did not start in Arc mode');
+    }
+}
+const DEFAULT_START_EVM_FORK_DEPS = {
+    spawnAnvil: defaultSpawnAnvil,
+    waitForReady: waitForEvmRpcReady,
+};
+/**
+ * Rejects if `port` on 127.0.0.1 is already bound. A bind-test up front closes
+ * the port-collision race: proving RPC health after spawn can otherwise pass
+ * against an unrelated node already listening on the port, before our freshly
+ * spawned anvil fails with EADDRINUSE.
+ */
+async function assertPortAvailable(port) {
+    await new Promise((resolve, reject) => {
+        const server = (0,node_net__WEBPACK_IMPORTED_MODULE_0__.createServer)();
+        server.once('error', (error) => {
+            const code = 'code' in error ? error.code : undefined;
+            reject(code === 'EADDRINUSE'
+                ? new Error(`port ${port} is already in use`)
+                : error);
+        });
+        server.once('listening', () => {
+            server.close(() => resolve());
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+// A single process-level `exit` hook kills every still-running fork, rather than
+// one listener per fork — which would trip MaxListenersExceededWarning past ten
+// forks and retain each child's closure until process exit. A fork joins the
+// registry on start and leaves when it is killed or its child exits.
+const runningForkKills = new Set();
+let forkExitHookInstalled = false;
+function trackForkExit(killFork) {
+    runningForkKills.add(killFork);
+    if (!forkExitHookInstalled) {
+        forkExitHookInstalled = true;
+        process.once('exit', () => {
+            for (const kill of Array.from(runningForkKills)) {
+                kill();
+            }
+        });
+    }
+    return () => {
+        runningForkKills.delete(killFork);
+    };
+}
+async function startEvmFork(config, deps = DEFAULT_START_EVM_FORK_DEPS) {
+    const endpoint = `${LOCAL_HOST}:${config.port}`;
+    // Fail fast if the port is taken, before spawning, so we never treat another
+    // process's RPC as our fork.
+    await assertPortAvailable(config.port);
+    let killOnError;
+    try {
+        let anvilProcess;
+        try {
+            anvilProcess = deps.spawnAnvil(config);
+        }
+        catch (error) {
+            // A synchronous spawn throw (e.g. execa rejecting an argument that
+            // contains a NUL byte) can embed the credential-bearing URL in its
+            // message; sanitize it at the source so it never leaks.
+            throw sanitizeAnvilError(error, config);
+        }
+        const onProcessExit = () => {
+            void kill(false).catch((error) => (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logDebug */ .MD)(`Failed to kill anvil fork for chain ${config.chainName}`, error));
+        };
+        const kill = async (isPanicking) => {
+            untrackFork();
+            anvilProcess.kill(isPanicking ? 'SIGTERM' : 'SIGINT');
+        };
+        killOnError = kill;
+        // Kill this fork if the process exits; drop it from the registry once the
+        // child is gone (killed or exited) so a single process-level `exit` hook
+        // covers any number of forks without accumulating listeners. Registered
+        // before the readiness race so the failure path's kill can untrack it.
+        const untrackFork = trackForkExit(onProcessExit);
+        void anvilProcess.then(() => untrackFork(), () => untrackFork());
+        const provider = new _ethersproject_providers__WEBPACK_IMPORTED_MODULE_6__.JsonRpcProvider(endpoint);
+        // Abort the readiness probe the instant the race settles so no retry timer
+        // keeps polling a dead port after anvil exits before its RPC is ready.
+        const controller = new AbortController();
+        const readiness = deps.waitForReady(provider, controller.signal, config.chainName, config.chainId);
+        // Reject if anvil exits before its RPC is ready (e.g. the port is already
+        // occupied) so we never treat another process's RPC as our fork.
+        const exited = anvilProcess.then(() => {
+            throw new Error('anvil exited before its RPC was ready');
+        }, (error) => {
+            throw sanitizeAnvilError(error, config);
+        });
+        // A later exit (e.g. on kill once readiness has won) must not surface as an
+        // unhandled rejection after the race settles.
+        exited.catch(() => { });
+        try {
+            await Promise.race([readiness, exited]);
+        }
+        finally {
+            controller.abort();
+        }
+        return new RunningEvmFork(provider, endpoint, kill);
+    }
+    catch (error) {
+        // Kill any running anvil process otherwise the process will keep running
+        // in the background.
+        if (killOnError) {
+            await killOnError(true);
+        }
+        // Both anvil-error sources are sanitized at their source (the synchronous
+        // spawn throw above and the async `exited` mapping), so no URL-bearing error
+        // reaches here; rethrow verbatim to preserve real readiness/exit messages.
+        throw error;
+    }
+}
+class EvmForkManager {
+    config;
+    deps;
+    running;
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+    }
+    get requireRunning() {
+        const running = this.running;
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_4__/* .assert */ .v)(running, `Fork not started for chain ${this.config.chainName}`);
+        return running;
+    }
+    async start() {
+        this.running = await startEvmFork(this.config, this.deps);
+    }
+    async applyForkConfig(config) {
+        const { provider } = this.requireRunning;
+        await handleImpersonations(provider, this.config.chainName, config.impersonateAccounts);
+        await handleTransactions(provider, this.config.chainName, config.transactions);
+    }
+    getForkedChainMetadata() {
+        return {
+            rpcUrls: [{ http: this.requireRunning.endpoint }],
+            blocks: { confirmations: 1 },
+        };
+    }
+    kill() {
+        void this.running
+            ?.kill(false)
+            .catch((error) => (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logDebug */ .MD)(`Failed to kill anvil fork for chain ${this.config.chainName}`, error));
+    }
+}
+function createEvmForkManagerFactory(multiProvider) {
+    return (ctx) => {
+        const metadata = multiProvider.getChainMetadata(ctx.chainName);
+        return new EvmForkManager({
+            chainName: metadata.name,
+            chainId: metadata.chainId,
+            upstreamRpcUrl: ctx.upstreamRpcUrl,
+            port: ctx.port,
+        });
+    };
+}
+async function handleImpersonations(provider, chainName, accountsToImpersonate) {
+    if (accountsToImpersonate.length === 0) {
+        return;
+    }
+    (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Impersonating accounts ${accountsToImpersonate} on chain ${chainName}`);
+    await Promise.all(accountsToImpersonate.map((address) => provider.send('anvil_impersonateAccount', [address])));
+}
+async function handleTransactions(provider, chainName, transactions) {
+    if (transactions.length === 0) {
+        return;
+    }
+    (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Executing transactions on chain ${chainName}`);
+    let txCounter = 0;
+    for (const transaction of transactions) {
+        const signer = provider.getSigner(transaction.from);
+        await provider.send('anvil_setBalance', [
+            transaction.from,
+            '10000000000000000000',
+        ]);
+        let calldata;
+        if (transaction.data?.type === _recoillink_sdk__WEBPACK_IMPORTED_MODULE_7__/* .TransactionDataType */ .pp.RAW_CALLDATA) {
+            calldata = transaction.data.calldata;
+        }
+        else if (transaction.data?.type === _recoillink_sdk__WEBPACK_IMPORTED_MODULE_7__/* .TransactionDataType */ .pp.SIGNATURE) {
+            const functionInterface = new ethers__WEBPACK_IMPORTED_MODULE_8__.ethers.utils.Interface([
+                transaction.data.signature,
+            ]);
+            const [functionName] = Object.keys(functionInterface.functions);
+            calldata = functionInterface.encodeFunctionData(functionName, transaction.data.args);
+        }
+        const annotation = transaction.annotation ?? `#${txCounter}`;
+        // Advance once per iteration (before any `continue`) so fallback `#n`
+        // annotations stay unique even when a tx short-circuits on a revert assert.
+        txCounter++;
+        (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Executing transaction on chain ${chainName}: "${annotation}"`);
+        let pendingTx;
+        try {
+            pendingTx = await signer.sendTransaction({
+                to: transaction.to,
+                data: calldata,
+                value: transaction.value,
+            });
+        }
+        catch (error) {
+            const reason = getRevertReason(error);
+            if (reason && transaction.revertAssertion) {
+                assertRevert(transaction.revertAssertion, reason, {
+                    chainName: chainName,
+                    transactionAnnotation: annotation,
+                });
+                continue;
+            }
+            // New unhandled error
+            throw error;
+        }
+        const txReceipt = await pendingTx.wait();
+        if (txReceipt.status == 0) {
+            throw new Error(`Transaction "${annotation}" reverted on chain ${chainName}`);
+        }
+        transaction.eventAssertions.forEach((eventAssertion, idx) => assertEvent(eventAssertion, txReceipt.logs, {
+            chainName: chainName,
+            assertionIdx: idx,
+            transactionAnnotation: annotation,
+        }));
+        if (transaction.timeSkip) {
+            (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Forwarding time by "${transaction.timeSkip}" seconds on chain ${chainName}`);
+            await provider.send('evm_increaseTime', [transaction.timeSkip]);
+        }
+    }
+    (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Successfully executed all transactions on chain ${chainName}`);
+}
+function getRevertReason(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'reason' in error &&
+        typeof error.reason === 'string') {
+        return error.reason;
+    }
+    return undefined;
+}
+function assertRevert(revertAssertion, reason, meta) {
+    // If contract call reverts, then there should be a reason
+    // https://github.com/ethers-io/ethers.js/blob/v5.7/packages/providers/src.ts/json-rpc-provider.ts#L79
+    if (reason !== revertAssertion.reason) {
+        throw new Error(`Expected revert: ${revertAssertion.reason} does not match ${reason}`);
+    }
+    const annotation = revertAssertion.annotation ?? revertAssertion.type;
+    (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Successfully completed revert assertion on chain "${meta.chainName}" and transaction "${meta.transactionAnnotation}": "${annotation}"`);
+}
+function assertEvent(eventAssertion, rawLogs, meta) {
+    const [rawLog] = rawLogs.filter((rawLog) => eventAssertion.type === _recoillink_sdk__WEBPACK_IMPORTED_MODULE_7__/* .EventAssertionType */ .l.RAW_TOPIC
+        ? assertEventByTopic(eventAssertion, rawLog)
+        : assertEventBySignature(eventAssertion, rawLog));
+    if (!rawLog) {
+        throw new Error(`Log ${eventAssertion.type === _recoillink_sdk__WEBPACK_IMPORTED_MODULE_7__/* .EventAssertionType */ .l.RAW_TOPIC
+            ? eventAssertion.topic
+            : eventAssertion.signature} not found in transaction!`);
+    }
+    const annotation = eventAssertion.annotation ?? `#${meta.assertionIdx}`;
+    (0,_logger_js__WEBPACK_IMPORTED_MODULE_5__/* .logGray */ ._P)(`Successfully completed assertion on chain "${meta.chainName}" and transaction "${meta.transactionAnnotation}": "${annotation}"`);
+}
+function assertEventByTopic(eventAssertion, rawLog) {
+    return rawLog.topics[0] === eventAssertion.topic;
+}
+function assertEventBySignature(eventAssertion, rawLog) {
+    const eventInterface = new ethers__WEBPACK_IMPORTED_MODULE_8__.ethers.utils.Interface([eventAssertion.signature]);
+    let parsedLog;
+    // parseLog throws if the event cannot be decoded
+    try {
+        parsedLog = eventInterface.parseLog(rawLog);
+        if (!parsedLog) {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+    if (!eventAssertion.args) {
+        return true;
+    }
+    const logArgs = parsedLog.args
+        .slice(0, eventAssertion.args.length)
+        .map((arg) => String(arg));
+    return (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_9__/* .deepEquals */ .c2)(logArgs, eventAssertion.args);
+}
+//# sourceMappingURL=EvmForkManager.js.map
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } });
+
+/***/ })
+
+};