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!