mrkeyoor.comAsk

0xhamssog/evem-transaction-managertested 13 Nov 2026commit 82c7b2f

evem-transaction-manager review

Our sandbox built evem-transaction-manager in 11 seconds, but its test command exited 1 with the Anvil integration file failed.

  • Install failed
  • Build 11 s
43/46passed, run exited non-zero
  • 383 packages
Dev Toolsevaluationupdated 14 Nov 2026
+0stars / 7d

evem-transaction-manager is a TypeScript reference implementation for tracking EVM transactions from submission through confirmation and reconciliation. It gives automated senders a place to manage nonces, stored attempts and retries without putting that bookkeeping inside a trading strategy.

Verdict

Our sandbox built evem-transaction-manager in 11 seconds, but its test command exited 1 with the Anvil integration file failed. Use it if you want a TypeScript reference for transaction lifecycle engineering and can investigate that integration result. Skip it if you need an audited production component or a multi-signer queue: the README explicitly excludes both.

Infographic on how evem-transaction-manager works, its uses, our test result, common pitfalls and who should use it
Tested 13 November 2026: npm install failed after 2 s. Before that: source install 51 s, build 11 s.

We ran it

Lab card: what happened when we ran evem-transaction-manager
Lab card from our sandbox run
Screenshot of evem-transaction-manager (github.com/0xhamssog/evem-transaction-manager)
github.com/0xhamssog/evem-transaction-manager
Install✓ · 51s383 packages · 179 MB
Build✓ · 11s
Tests✗ · 8s43 passed · 0 failed · 3 skipped of 46 (vitest)
Known vulns00 critical · 0 high · 0 moderate · 0 low (npm audit)
Repo61 files~5,397 lines of source · 0.4 MB · 0 CI workflows · tests dir

Answers from our run

Does evem-transaction-manager build from source?

Dependencies installed in 51 seconds (383 packages), and the build succeeded in 11 seconds. We cloned commit 82c7b2f into a clean Debian container with 3 CPUs and no project-specific setup.

Do evem-transaction-manager's tests pass?

No. The project's own test command finished in 8 seconds and reported 43 passed, 0 failed, 3 skipped (vitest).

Does evem-transaction-manager have known vulnerabilities in its dependencies?

npm audit found none in the dependency tree at the time of our run.

Who should not use evem-transaction-manager?

Teams requiring an audited production component.

What are the alternatives to evem-transaction-manager?

viem, ethers, MultiBaas TXM. Our sandbox built evem-transaction-manager in 11 seconds, but its test command exited 1 with the Anvil integration file failed.

Setup2/5In our 2026-11-13 run “npm install evm-transaction-manager@latest” failed with “npm error A complete log of this run can be found in: /work/home/.npm…”, though our source checkout installed in 51 s and built in 11 s.Editor’s note: Source installation and build succeeded, but actual runtime logs and the failed integration exception are missing; full-workflow setup ease is unassessed.
Docs4/5The README has an install section (“Local setup”) and a usage section (“Example”); we did not run its quickstart ourselves.Editor’s note: The visible rubric awards 4 for detailed configuration and failure-state guidance. The README and nonce and reconciliation documents support that judgment; 5 additionally requires corroboration across important operating paths.
Community2/5Last push on 2026-10-03 and 160 stars.Editor’s note: The supplied records contain no usable support-response sample or named adopter account from which to assess community support.
Maturity1/5No tagged GitHub release, repository created 2026-10-03 and its test suite did not pass in our sandbox (43 of 46 passed).Editor’s note: The README identifies an unaudited reference implementation, and the supplied runs do not establish a completed chain workflow or production operating history.

How we score

Who it’s for

TypeScript developers studying transaction lifecycle design for an automated EVM sender.
Engineers who want to adapt a viem-backed reference with SQLite persistence.
Contributors investigating the failed Anvil integration run.

Who it’s NOT for

Teams requiring an audited production component.
Applications requiring a multi-signer queue, private transaction relay or L2-specific fee market.
Operators expecting cancellation to remove a pending transaction from the mempool.
Developers requiring the attempted npm package route.

Setup reality

Our 2026-11-13 source-checkout run at 82c7b2f installed dependencies in 51 seconds and built in 11 seconds, recording 383 dependencies and 179 MB. Tests exited 1 after 8 seconds: Vitest reported 43 passed, 0 failed and 3 skipped of 46, with the Anvil integration file failed. npm audit recorded zero known vulnerabilities.

The README requires Node.js 22 or newer, npm and Foundry. Its examples use an RPC endpoint, chain configuration, a signing key and SQLite storage. The separate package-based install failed in 2 seconds with exit 1: npm returned E404 for evm-transaction-manager@latest, including a 404 response to GET https://registry.npmjs.org/evm-transaction-manager.

The source sandbox configuration recorded 3 CPUs, 8 GB RAM and image lab-node:22. The test tail points to test/integration/anvil.test.ts:46:5. Runtime-version and failure-diagnosis gaps are collected in the final section.

Short answer

Our sandbox built evem-transaction-manager successfully, but the test command exited 1 with 43 passed and 3 skipped tests. Use it if you want a TypeScript reference for keeping an automated EVM sender's transactions accounted for. Skip it if you need an audited production component or a multi-signer queue. The project README describes its role and supplies the adoption boundaries collected in the final section.

The useful design distinction is between submitting a transaction and knowing its outcome. The documented API gives one logical action an identity that survives changes to its transaction hash. That matters when a pending action needs a fee increase or a process restarts. Your application owns the decision to trade. This project supplies the bookkeeping between that decision and the chain's answer, including the case where the call reverted.

What people use evem-transaction-manager for

The author proposes evem-transaction-manager as infrastructure beneath automated trading applications. In the author's DEV article, hamssog lists automated trading bots, arbitrage systems, copy-trading systems, Pons applications, stock-token trading systems, trading terminals and custom EVM applications. The author's Substack article also names sniper infrastructure. These lists describe the intended applications of the transaction layer and give developers several concrete integration contexts to examine.

For an arbitrage developer, the relevant design is the separation between a trading signal and its execution record. A copy-trading developer has the same accounting question: which submitted action actually succeeded? A terminal developer could use the logical transaction ID to follow an action through pending and replacement states. Each use follows the README's distinction between an application that chooses an action and infrastructure that tracks its execution.

The README's API illustrates the intended integration: call submit, keep the returned transaction ID, wait for confirmation and request reconciliation. That gives the caller a place to ask about the whole action instead of tracking only the first hash. The transaction ID identifies the action while the attempt history records its hashes. This structure lets application code preserve the relationship between the original request, replacements and the eventual receipt.

What happened when we ran it

Our separate npm-package install failed in 2 seconds with exit 1 and E404. The failed install step records npm install evm-transaction-manager@latest and a 404 response to GET https://registry.npmjs.org/evm-transaction-manager. The run record dates the attempt to 2026-11-13 and associates it with commit 82c7b2f22208, using an unprivileged container with 2 CPUs and 4 GB RAM. Its summary says "installed", but the failed step and finding establish the outcome.

The clone step records the quickstart-lib recipe in 1 second. The attempt then stopped at installation, and the install-failed finding points to /work/home/.npm/_logs/2026-11-13T19_40_45_486Z-debug-0.log. The teardown record says teardown completed successfully. The repository name is evem-transaction-manager; the requested npm name was evm-transaction-manager. Keeping those spellings visible helps distinguish the checkout from the package request.

The source-checkout run completed dependency installation and build. On 2026-11-13, our sandbox at commit 82c7b2f installed dependencies in 51 seconds and built in 11 seconds. We measured 383 dependencies occupying 179 MB. The test command then exited 1 after 8 seconds. These results describe a separate route from the registry attempt: the source checkout reached build and tests, while the npm-package attempt stopped at installation.

Source-checkout check Our recorded result What it tells you
Dependency installation Succeeded in 51 seconds The checkout's dependencies installed in this sandbox.
Build Succeeded in 11 seconds The recorded build command completed.
Test command Exit 1 after 8 seconds The command failed overall.
Vitest summary 43 passed, 0 failed, 3 skipped of 46 Passing assertions did not produce a passing command.
Test files 1 failed, 7 passed The failing file was the Anvil integration file.
npm audit 0 known vulnerabilities The recorded dependency scan found no known advisories.

The source sandbox configuration recorded 3 CPUs, 8 GB RAM and image label lab-node:22. The checkout contained 61 files, approximately 5,397 source lines and 0.4 MB. The scan found a tests directory, no CI workflow files and no Dockerfile. These are the recorded configuration and repository observations for the checkout at 82c7b2f, kept separate from the smaller container described in the npm-package run record.

The test tail points to test/integration/anvil.test.ts:46:5. That file reports three skipped tests while its file-level result is failed. Vitest reports seven passing files and one failed file, alongside the 43 passing tests. The command outcome therefore remains unsuccessful. For a contributor, the next concrete task is to obtain the complete integration log and reproduce the README's local-chain path, preserving the exception and receipts alongside the command result.

Where people get stuck: package delivery and ambiguous transaction states

The npm E404 concerns package retrieval; the failed Anvil file concerns tests inside a source checkout. These are separate setup findings with separate next steps. A registry investigation starts with the exact package name and response. An integration investigation starts with the failed file and complete log. Keeping that distinction in an issue report gives a maintainer the route, command and outcome needed to understand which problem occurred.

Symptom or state Supported interpretation Useful next action
npm E404 for evm-transaction-manager@latest The requested package was absent in our recorded attempt. Follow the README's checkout-based setup route for evaluation.
Anvil integration file failed with skipped cases The overall test command failed; the tail omits the exception. Read the complete log before selecting a fix.
RECONCILIATION_REQUIRED after an uncertain broadcast The documented policy preserves uncertainty about submission. Reconcile through the manager instead of allocating a fresh nonce for the same action.
A reconciled record has a reverted receipt Reconciliation accounted for an unsuccessful call. Read receipt status before marking the application action successful.

The latter rows describe behavior in the reconciliation documentation. An explicit uncertainty state asks the caller to investigate the existing action. The recovery description uses the stored signed payload, preserving the original hash as the object being investigated. That gives a caller a specific recovery path after an ambiguous broadcast: follow the stored attempt and reconcile its chain state before deciding what business action should follow.

Concurrent callers share a documented per-account queue

The nonce documentation describes NonceLock as a per-account promise queue covering the chain read, reservation write and cursor update. Its allocator accounts for both the node's latest and pending transaction counts, plus locally reserved or submitted nonces. This addresses the race in which several callers each ask the node for the next nonce before their transactions become visible there. The nonce-management document explains the allocation sequence.

The database and allocator consequently belong in the integration design. A reserved nonce represents work the node may not yet know about. The docs restrict release to a reservation whose broadcast definitely did not happen. A timeout while sending has a different meaning: the node may already have the payload. In that case the documented policy keeps the nonce submitted and moves the record to RECONCILIATION_REQUIRED.

The same document distinguishes inspecting the next nonce from reserving it. getNextNonce reports the value allocation would use, while allocateNonce performs the reservation. An explicit nonce must equal the next safe value. These distinctions matter when adapting a caller that already supplies nonces: the manager's local reservation record participates in allocation alongside the node's counts, so the application should preserve that ownership rather than independently selecting a competing value.

A reconciled transaction can still have reverted

The reconciliation document says a reverted receipt moves through REVERTED to RECONCILED, keeping TRANSACTION_REVERTED as its error code. An application that treats the final state name as a successful trade would misread the documented API. The caller needs receiptStatus and outcome as well as the lifecycle status. Accounting for a failed call completes the reconciliation task while preserving the unsuccessful execution result for application code.

The document describes looking through known hashes, newest first, then reading the transaction and receipt. Confirmation depth has its own condition. A receipt below the configured depth reports pending_confirmations, while a known included hash without a receipt produces missing_receipt. These outcomes give the application more information than a single completion flag. Preserve the distinction when displaying transaction progress or deciding whether another action depends on this one.

The README also separates retry policies. Connection refusal before acceptance calls for resending the same signed bytes. A pending timeout can lead to a replacement with the same nonce and higher fees. Contract reverts and invalid requests stop. An integration should keep that classification visible to the code scheduling business actions, because each case answers a different question about whether the original request reached the node and what happened afterward.

Security starts with the local signing key

The README warns that its sample private key is Foundry's published local account and must not be used where value can be lost. Local examples use a chain endpoint and signing configuration, and the default database path is ./data/transactions.sqlite. Configure those deliberately before running an example against an endpoint. The sample account is suitable for the documented local-node instructions, and its public identity is part of those instructions.

The project's stated persistence policy stores signed transaction payloads for rebroadcast and excludes private keys from SQLite. Its stated amount-handling policy uses bigint for on-chain values and decimal text in storage. These choices support the described recovery path, which needs the original signed attempt. The README also distinguishes integer nonces and chain IDs from stored decimal amounts, giving an integrator concrete data representations to preserve when adapting storage or reporting code.

Our npm audit recorded zero known vulnerabilities. The README's security rules separately describe preserving the nonce on replacement, avoiding retries of reverted receipts and retaining uncertainty in RECONCILIATION_REQUIRED. Those rules connect transaction accounting to application behavior. A caller still chooses the destination, calldata, value and fee configuration, then interprets the receipt when deciding whether the requested action succeeded. The dependency-scan result and documented transaction rules answer different engineering questions.

evem-transaction-manager vs viem, ethers and MultiBaas TXM

Viem documents Ethereum client primitives, ethers documents wallet and contract interfaces, and MultiBaas TXM documents a Cloud Wallet transaction workflow. The comparison below uses those documented roles as the decision aid. Start with the responsibility your application needs to own: client access, a local persisted lifecycle, or the Cloud Wallet workflow. The manager's own README places ViemEvmClient at its RPC boundary, so using viem can be part of adopting this reference.

Option Documented role Pick it when
evem-transaction-manager Reference lifecycle manager with a viem adapter and SQLite persistence You want to inspect and adapt an explicit transaction-state model.
viem TypeScript Ethereum interface with JSON-RPC and smart-contract APIs You want client primitives and intend to own the surrounding lifecycle.
ethers Ethereum library with wallet, contract ABI and provider support Your integration needs those library interfaces and its own execution accounting.
MultiBaas TXM Monitors Cloud Wallet transactions and resubmits them when required You want to evaluate that Cloud Wallet workflow and operator interface.

The viem README describes JSON-RPC abstractions, smart-contract APIs and ABI utilities. The ethers README describes wallet import and export, contract objects generated from ABIs, and connections to Ethereum nodes. Those are useful alternatives when an application already owns its transaction accounting. Adopting this manager instead means examining its additional persistence and lifecycle decisions alongside the underlying Ethereum client interface.

Curvegrid's MultiBaas TXM documentation says the TXM monitors Cloud Wallet transactions, reports status and automatically resubmits them when required. It also describes controls for resubmitting pending transactions with higher gas fees. That workflow gives an evaluator a different starting point from adapting a local TypeScript reference: inspect the Cloud Wallet transaction interface and its operating controls, then decide whether that integration model matches the application.

FAQ

The documented source setup requires Node.js 22 or newer, npm and Foundry. The README's local setup section lists installation, build and test commands, followed by Anvil and example commands. The source-checkout measurements above describe the outcomes of our run. For a first evaluation, keep the checkout, local chain, mock-contract build and example output together so the transaction receipt can be connected to the action being examined.

How do I get started with evem-transaction-manager?

The README lists npm install and npm run build as part of its source setup, alongside npm checks and Foundry commands. It then starts Anvil and runs submission, waiting and revert examples. The revert example needs built mock-contract artifacts unless a reverter address is already configured. Follow the documented local setup in that order, keeping the contract-build requirement attached to the revert example.

Does RECONCILED mean the transaction succeeded?

No. The reconciliation document explicitly allows a reverted receipt to reach RECONCILED. Read receiptStatus and outcome to distinguish a successful call from an accounted-for revert. Preserve those fields in the application's own status model, especially when a subsequent action depends on successful execution. A lifecycle record can finish its chain check while still reporting that the requested contract call failed.

What does the local revert example do?

The README says examples/simulate-failure.ts deploys MockRevertingTarget, shows simulation failure without broadcast, then submits with simulate: false and an explicit gas limit so the reverted receipt is recorded without retrying it. Its example description gives a concrete way to study the distinction between a simulation failure and an included transaction that reverts. The example's deployment requirement is described in the local setup instructions.

The documentation rating covers explanations and boundaries

The documentation rating is 4/5 for the README's API, configuration and retry guidance plus the separate nonce and reconciliation documents. Our visible rubric assigns 1 to little usable instruction, 3 to a usable basic path, 4 to detailed guidance covering configuration and failure states, and 5 to that guidance corroborated across important operating paths. The supplied documents support the 4 through specific allocation, retry and receipt-handling explanations.

Setup, community and production maturity are unassessed and render as N/A. Their evidence gaps are collected in the final section. The documentation judgment concerns the material a reader can use to understand and integrate the design: local prerequisites, configuration variables, lifecycle states, failure classifications and recovery descriptions. It remains separate from the measured command outcomes, including the successful source build and the unsuccessful overall test command.

What we have not tested yet

Our evidence stops before a completed live-chain transaction workflow. The package-based attempt stopped at installation, and the source run's Anvil integration file failed with skipped cases. The supplied test tail omits the underlying exception, so a missing executable, package defect or Node mismatch would be an unsupported diagnosis. The lab-node:22 image label also leaves actual runtime and operating-system versions unresolved; those require the raw toolchain logs.

The supplied author articles describe intended applications without a named adopter, deployment report or measured trading outcome. Their concurrency and crash-recovery discussions describe engineering designs. The passing assertions have not been independently mapped to each documented scenario, and the supplied runs leave process-kill recovery, coordination across processes, replacement acceptance across EVM clients, reorganizations and sustained RPC outages untested. The project documents provide implementation descriptions rather than observations of those deployment conditions.

The README identifies an unaudited reference implementation. Its fallback block scan looks back 25 blocks; cancellation stops local monitoring without removing a transaction from the mempool; and it has no multi-signer queue, private transaction relay or L2-specific fee market beyond EIP-1559 fields. Replacement fees follow configured bumps without a promise that every client accepts them. The persistence and key-handling descriptions also remain outside a credential-handling or storage-security audit, and npm audit is limited to known dependency advisories.

The supplied GitHub repository metadata, observed on 2026-11-14, records 160 stars, zero open issues and PRs combined, and a last push of 2026-10-03. The supplied metadata does not establish a latest release. It supplies no support-response history or production operating record. The related-page evidence contains no competing EVM lifecycle review; the repository-explorer placeholder, video records without usable transcripts and X search without actual-use posts add no operational proof.

The supplied material also leaves rendered layout, accessibility, automatic related links and recommendation modules untested. This correction assesses the supplied public text and evidence. The next useful transaction evidence would preserve the database, signed attempts and node receipts while deliberately interrupting submission and recovery, alongside the complete integration exception and actual toolchain versions. That would address the remaining operational questions more directly than another summary of the documented feature list.

Alternatives

ProjectWhat it isPick it when
viemA TypeScript Ethereum interface with JSON-RPC and smart-contract APIs.Pick viem directly when you want client primitives and will own the transaction lifecycle around them.
ethersAn Ethereum library with wallet, contract ABI and provider support.Pick ethers when those interfaces fit your application and you intend to own execution accounting.
MultiBaas TXMA transaction-management workflow for MultiBaas Cloud Wallet transactions.Evaluate it when you want that Cloud Wallet workflow, including monitoring and resubmission controls.

Sources

  1. Project README
  2. Nonce management documentation
  3. Reconciliation documentation
  4. Author on intended trading integrations
  5. viem README
  6. ethers README
  7. MultiBaas TXM documentation

More dev tools reviews