Comprehensive Comparison and ultimate stand off of the dhive vs hive-tx vs hive-js vs wax libraries/packages helps you interact with Hive blockchain. Our team find these type of comparisons and analysis valuable to see which library to use when building on Hive.

Overview --------

	@hiveio/hive-js	@hiveio/dhive	hive-tx	@hiveio/wax
Maintainer	@hiveio (community)	@hiveio (community)	@mahdiyari	@hiveio (core+community)
Language	JavaScript (ES6+Babel)	TypeScript 3.8	TypeScript 5.9	TypeScript + C++/WASM
Runtime deps	27	11+	4	1 (events)
Bundle size (gzip)	~154 KB	~210 KB	~29 KB	~3,341 KB
Source lines	~7,337	~5,956	~3,633	~8,796 + C++
Test lines	~1,500+	~1,579	~870	~18,339
Node.js req	4+	8+	20+	20.11+
Operations	49 (+SMT)	50 + 36 virtual	50+	100+
Type definitions	None	Full TS	Full TS	Full TS + branded
License	MIT	BSD-3-Clause-NML	—	—

* * * 1\. Architecture Philosophy --------------------------- **hive-js** — Fork of steem-js, the original Steem/Hive JS library. Callback-and-promise hybrid API using Bluebird's `promisifyAll`. Modular design with 7 top-level namespaces (`api`, `auth`, `broadcast`, `formatter`, `memo`, `config`, `utils`). Supports both HTTP and WebSocket transports (discontinued). The most "batteries-included" but also the heaviest and most legacy. **dhive** — Clean rewrite of hive-js in TypeScript. OOP `Client` class with dedicated helper modules. Dropped WebSocket, callbacks, and Bluebird in favor of `async/await`. Leaner than hive-js but same conceptual model. **hive-tx** — Minimalist, transaction-focused. No client class — configure globals and call standalone functions. Only 4 runtime deps. Modern ESM-first. Deliberately does less but does it with the smallest footprint. **wax** — Three-layer: Protobuf → C++ WASM → TypeScript. The C++ core is the same code Hive nodes run. Heaviest bundle but strongest protocol guarantees. Pluggable signer architecture for wallet integrations. * * * 2\. Dependencies & Supply Chain -------------------------------

	hive-js	dhive	hive-tx	wax
Crypto	ecurve, bigi, create-hash, browserify-aes, secure-random, ripemd160	secp256k1 (native), ecurve, bigi, ripemd160	@noble/curves, @noble/hashes, @noble/ciphers	C++ WASM (zero JS crypto)
HTTP	cross-fetch, ws	cross-fetch, node-fetch	Native fetch	Native fetch
Binary	bytebuffer	@ecency/bytebuffer	Custom `ByteBuffer.ts`	Protobuf + WASM
Promises	bluebird	Native	Native	Native
Utilities	lodash, debug, detect-node	verror, core-js, jsbi	None	events
Base58	bs58@4	bs58@4	bs58@6	WASM built-in
RPC auth	@steemit/rpc-auth	None	None	None
Total deps	27	11+	4	1

**Verdict:** `hive-js` has the largest attack surface — 27 deps including lodash, bluebird, and legacy Steem packages. `hive-tx` is the leanest (4 audited `@noble` libs). `wax` has zero JS crypto deps. * * * 3\. Transport & Streaming -------------------------

Feature	hive-js	dhive	hive-tx	wax
HTTP/JSON-RPC	Yes	Yes	Yes	Yes
WebSocket	Yes	No	No	No
Block streaming	Yes (polling)	Yes (AsyncIterator)	No	No
Op streaming	Yes (`streamOperations`)	Via block stream	No	No
Tx streaming	Yes (`streamTransactions`)	Via block stream	No	No
Stream modes	head / irreversible	head / irreversible	—	—
Stream control	Release function	AsyncIterator break	—	—
REST API	No	No	Yes (9 typed endpoints)	Yes (extensible)

`hive-js` has the most granular streaming — you can stream block numbers, blocks, transactions, or individual operations separately. `dhive` provides a single `getBlockStream()` AsyncIterator that's more idiomatic modern JS. Neither `hive-tx` nor `wax` support streaming. * * * 4\. Crypto Operations ---------------------

Capability	hive-js	dhive	hive-tx	wax
Key from WIF	Yes	Yes	Yes	Via signers
Key from seed	Yes	Yes	Yes	No
Key from login	Yes	Yes (`fromLogin`)	Yes (`fromLogin`)	No
Random key gen	Yes (`secure-random`)	No	Yes (`randomKey`)	No
Brain key	Yes	No	No	No
ECDSA signing	Yes	Yes	Yes	Yes (WASM)
Signature recovery	Yes	Yes	Yes	Yes
Memo encrypt/decrypt	Yes	Yes	Yes	Yes
Password verification	Yes (`isWif`, `wifIsValid`)	No	No	No
Key leak detection	No	No	No	Yes
Multiple signer backends	No	No	No	Yes (5 packages)

`hive-js` has the most key-related utilities (brain keys, password verification, role-based generation). `wax` is the most flexible for dApp integrations with pluggable signers. * * * 5\. API Surface ---------------

API Surface	hive-js	dhive	hive-tx	wax
Defined API methods	95	~30	Raw RPC	~10 typed
`database_api`	Yes (many methods)	`DatabaseAPI` class	Via `callRPC`	Typed defs
`condenser_api`	Yes (primary)	Partial	Via `callRPC`	No
`broadcast`	`broadcast.*` namespace	`BroadcastAPI` class	`Transaction.broadcast()`	`OnlineTransaction`
Block streaming	`streamBlock/Ops/Tx`	`Blockchain` helper	No	No
RC API	Yes	`RCAPI` class	Via `callRPC`	Typed `rc_api`
Hivemind	Yes	`HivemindAPI` class	Via `callRPC/REST`	Via REST
`market_history_api`	Yes	No	Via `callRPC`	No
Formatter utilities	Yes (reputation, vest→HIVE, account value)	No	No	Yes (`WaxFormatter`)
Auth helpers	Yes (add/remove key/account auth)	No	No	Yes (`AccountAuthorityUpdate`)
Complex op builders	No	No	No	Yes (`BlogPost`, `Reply`, etc.)
Quorum verification	No	No	Yes	No
Request interceptors	No	No	No	Yes

`hive-js` has the broadest legacy API coverage (95 methods). `wax` has the richest operation builders. `hive-tx` is the only one with quorum verification. * * * 6\. Serialization -----------------

Feature	hive-js	dhive	hive-tx	wax
Approach	Hand-written (3,200+ lines ops)	Hand-written (681 lines)	Hand-written (784 lines)	Protobuf + C++ WASM
Buffer lib	`bytebuffer` (npm)	`@ecency/bytebuffer`	Custom (612 lines)	Protobuf
Type system	Most verbose (1,187 lines)	Moderate	Moderate	Proto-generated
HF26 support	No	No	No	Yes
Legacy support	Yes (primary)	Yes (primary)	Yes (primary)	Yes (compat)
Binary debugging	No	No	No	Yes (`binaryViewMetadata`)
Protocol fidelity	Manual sync	Manual sync	Manual sync	Byte-for-byte match

`wax` wins on serialization correctness — it's the same C++ code the chain runs. The other three all maintain hand-written serializers that could theoretically diverge from the protocol. * * * 7\. Type Safety & Developer Experience --------------------------------------

Feature	hive-js	dhive	hive-tx	wax
Language	JavaScript	TypeScript 3.8	TypeScript 5.9	TypeScript 5.x
Type definitions	None	Full	Full	Full + branded
Strict mode	N/A	Partial	Full	Full
ESM support	No (CJS only)	No (CJS only)	Yes (ESM+CJS+UMD)	Yes (ESM+CJS)
Tree-shaking	No	No	Yes	Partial
API style	Callbacks + Promises (Bluebird)	`async/await`	`async/await`	`async/await`
Operation typing	Runtime validation	Union types	Generic `addOperation<O>`	Protobuf-generated
IDE autocomplete	Poor	Good	Excellent	Excellent

`hive-js` is the weakest here — no TypeScript, no type definitions, callback-first API. `hive-tx` and `wax` offer the best modern DX. * * * 8\. Build & Bundle Size -----------------------

Feature	hive-js	dhive	hive-tx	wax
Build tool	Babel + Webpack	Make + Browserify	TypeScript + Webpack	Make + Rollup + Emscripten
Outputs	CJS `lib/` + UMD `dist/`	CJS `lib/` + UMD `dist/`	ESM + CJS + UMD	ESM + CJS + WASM
Minified	554 KB	~925 KB	~90 KB	~3,341 KB
Gzipped	154 KB	210 KB	~29 KB	~3,341 KB
Source maps	Yes	Yes	Yes	Yes

**Size ranking (smallest to largest gzipped):** `hive-tx` (29 KB) → `hive-js` (154 KB) → `dhive` (210 KB) → `wax` (3,341 KB) * * * 9\. Error Handling ------------------

Feature	hive-js	dhive	hive-tx	wax
Error class	`RPCError`	`VError` (wrapped)	`RPCError`	Rich hierarchy (`WaxError` → subtypes)
Error context	Code + message	Full chain (`VError`)	Code + message + data	Request/response + assertion hash
Failover trigger	Error count threshold	Per-API health tracking	Retry + node rotation	Health checker module
Broadcast safety	No special handling	Won't retry on timeout	Ignores duplicate tx	Authority verify pre-broadcast
Key leak detection	No	No	No	Yes

* * * 10\. Network Resilience -----------------------

Feature	hive-js	dhive	hive-tx	wax
Default timeout	Configurable	60,000 ms	10,000 ms	2,000 ms
Failover	Error-count threshold	Per-API health tracking	Round-robin retry	Health checker
Retry library	`retry` (npm)	Custom exponential backoff	Built-in	Built-in
Quorum reads	No	No	Yes	No
WebSocket fallback	Yes	No	No	No
RPC auth signing	Yes (`@steemit/rpc-auth`)	No	No	No

* * * 11\. Unique Features Per Library -------------------------------- ### hive-js only * WebSocket transport * 95 pre-defined API methods with docs * `streamOperations()` / `streamTransactions()` granular streaming * Brain key generation * Password/WIF validation utilities * Reputation formatter, vest-to-HIVE converter, account value estimator * Multi-signature authority helpers (`addKeyAuth`, `removeAccountAuth`) * RPC request signing (`@steemit/rpc-auth`) * SMT operation support (Smart Media Tokens) * Runs on Node.js 4+ ### dhive only * AsyncIterator block streaming (modern JS pattern) * Per-API health tracking (bridge failures don't penalize `database_api`) * VError context chains for debugging * Testnet helper (`Client.testnet()`) ### hive-tx only * `callWithQuorum()` — cross-check results across multiple nodes * 9 typed REST APIs (hafah, reputation, NFT tracker, hafsql, etc.) * Smallest bundle (29 KB gzip) * Only 4 runtime dependencies * ESM-first with tree-shaking ### wax only * C++ WASM core (byte-for-byte protocol match) * 5 pluggable signer packages (Beekeeper, MetaMask, Keychain, PeakVault, External) * Complex operation builders (BlogPost, Reply, Community, RC delegation) * Private key leak detection * Pre-broadcast authority verification * Binary view metadata for debugging * HF26 protobuf serialization format * Request/response interceptors * 18K lines of tests + benchmarks * * * 12\. When to Use Each --------------------- ### Use hive-js when: * You need WebSocket transport or RPC request signing * You want the broadest pre-defined API (95 methods, no manual RPC calls) * You need fine-grained streaming (operations, transactions, blocks separately) * You're maintaining a legacy codebase that already uses it * You need formatter utilities (reputation, vesting, account value) without writing your own * You need to support very old Node.js (4+) * Don't use for new projects if you care about types, bundle size, or modern JS ### Use dhive when: * You want a typed, async/await rewrite of hive-js concepts * You need block streaming with AsyncIterator * You need smart failover with per-API health tracking * The project already depends on it (large existing ecosystem) ### Use hive-tx when: * Bundle size is critical (29 KB — mobile, serverless, embedded) * You want minimal supply chain risk (4 deps) * You need quorum verification for security-critical reads * You want modern JS (ESM, tree-shaking, TS 5.9) * You need REST API support * You're building a lightweight tool or script ### Use wax when: * You need guaranteed protocol compatibility (same C++ as hive nodes) * You're building a dApp with wallet integrations (MetaMask, Keychain, etc.) * You need complex operation builders or authority verification * Security is paramount (key leak detection, pre-broadcast verification) * You want the most comprehensive test suite * Bundle size doesn't matter * * * Summary Matrix --------------

Dimension	Winner
Smallest footprint	hive-tx (29 KB, 4 deps)
Protocol fidelity	wax (C++ WASM)
Block/op streaming	hive-js (most granular)
Wallet integration	wax (5 signer packages)
Modern JS/TS DX	hive-tx (ESM, TS 5.9)
Broadest legacy API	hive-js (95 methods)
Complex op builders	wax (BlogPost, Community, etc.)
Test coverage	wax (18K lines)
Security features	wax (key leak, authority verify)
Network resilience	dhive (per-API health tracking)
Quorum consensus	hive-tx (unique)
Legacy compat	hive-js (Node 4+, callbacks)
REST APIs	hive-tx (9 typed endpoints)
Formatter utilities	hive-js (reputation, vesting, etc.)
WebSocket support	hive-js (only one)

Depending on what you are building, this comparison or overview gives you clear detailed differences. Keep on building! Hive on!