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 | ||||
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 | 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 ( | Via block stream | No | No |
Tx streaming | Yes ( | 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 ( | Yes ( | No |
Random key gen | Yes ( | No | Yes ( | 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 ( | 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 |
| Yes (many methods) |
| Via | Typed defs |
| Yes (primary) | Partial | Via | No |
|
|
|
|
|
Block streaming |
|
| No | No |
RC API | Yes |
| Via | Typed |
Hivemind | Yes |
| Via | Via REST |
| Yes | No | Via | No |
Formatter utilities | Yes (reputation, vest→HIVE, account value) | No | No | Yes ( |
Auth helpers | Yes (add/remove key/account auth) | No | No | Yes ( |
Complex op builders | No | No | No | Yes ( |
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 |
|
| 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 ( |
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) |
|
|
|
Operation typing | Runtime validation | Union types | Generic | 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 | CJS | 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 |
|
|
| Rich hierarchy ( |
Error context | Code + message | Full chain ( | 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 |
| Custom exponential backoff | Built-in | Built-in |
Quorum reads | No | No | Yes | No |
WebSocket fallback | Yes | No | No | No |
RPC auth signing | Yes ( | No | No | No |
11. Unique Features Per Library
hive-js only
WebSocket transport
95 pre-defined API methods with docs
streamOperations()/streamTransactions()granular streamingBrain 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 nodes9 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!