Ultimate Stand off

in HiveDevs • 4 hours ago (edited)

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!

#hive #developers #builders #dapps #libraries #blockchain #development #web3 #comparison
4 hours ago in HiveDevs by
$12.06
  • Pending payout amount: $12.06
  • Breakdown: 0.00 HBD, 103.97 HIVE, 103.97 HP
  • Payout in 7 days
250 votes
Reply 5
Sort:  
  • Trending
    • [-]
     3 hours ago  

    That's a great comparison. Developers need this! 👍

    $0.00
      Reply
      [-]
       3 hours ago  

      Great comparison.

      As a builder in the Hive ecosystem and founder of HivePostify, I really appreciate this detailed breakdown.

      In my experience, choosing the right library depends on the use case. Lightweight apps benefit from hive-tx, while more complex dApps can use wax for security and protocol-level accuracy.

      I look forward to more of these in-depth technical comparisons in the Hive ecosystem.

      Posted Via HivePostify

      $0.00
        Reply
        [-]
         3 hours ago  

        Excellent breakdown.

        From HivePostify's perspective, this kind of deep comparison helps builders choose the right tools based on real needs instead of hype.

        We’ve seen that lightweight solutions like hive-tx work well for fast and scalable features. More complex applications can benefit from wax’s strong security and protocol-level accuracy.

        As the Hive ecosystem grows, this technical clarity is important for developers and platforms alike.

        Keep up the great work.

        $0.00
          Reply
          [-]
           7 minutes ago  

          Se ve una gran batalla 🧐

          $0.00
            Reply