Skip to content
Cardano Client Bindings

Overview

Cardano Client Bindings compiles Cardano Client Lib (CCL) into a native shared library (libccl.so / libccl.dylib / libccl.dll) using GraalVM native-image. Any language can call CCL’s offline Cardano operations via FFI — no JVM required at runtime.

Why?

Section titled “Why?”

Cardano Client Lib is a mature, feature-rich Cardano SDK covering key derivation, transaction building, Plutus data handling, governance, and more. Cardano Client Bindings makes selected CCL modules available as a native shared library with a C ABI, so Python, Go, Rust, and JavaScript reuse CCL’s exact, well-tested behavior — whether as the foundation for a wrapper library, a transaction builder, or for individual functions like crypto, address parsing, and CBOR serialization.

Where this fits in the ecosystem

Section titled “Where this fits in the ecosystem”

To be clear about what this is not: Cardano has excellent native libraries in all four of these languages — pycardano (Python), MeshJS and Lucid Evolution (TypeScript), pallas (Rust), gOuroboros and Apollo (Go), among others. If one of them serves your needs, use it — these bindings are not trying to replace them.

The bindings exist for the cases where a native library doesn’t quite fit:

  • Filling functionality gaps. When your library is missing a capability — Conway-era governance operations, offline Plutus execution-unit costing, DRep/committee key derivation, HD wallets — the bindings give you CCL’s full offline surface for exactly those pieces. Because they’re offline and stateless, they slot in alongside your existing library; no rip-and-replace.
  • A different API model. If you’re not happy with an imperative builder API, CCL’s declarative TxPlan YAML — describe the transaction, let the library select UTXOs, compute fees, and handle change — may fit you better.
  • One behavior, four languages. When the same transaction-building semantics must hold across polyglot services, a single core beats four independent implementations that can drift.
  • CCL semantics outside the JVM. Teams already using Cardano Client Lib get the same behavior — same test suite, same edge cases — in their non-JVM code.
  • A maintained fallback. Native libraries have occasionally gone unmaintained; these bindings ride on CCL’s active maintenance.

The honest costs of this approach: a ~50 MB platform-specific native binary in your dependency tree, no node-protocol/chain-sync support (offline operations only, by design), and platform gaps a pure-language library wouldn’t have.

What’s included

Section titled “What’s included”

The bindings expose CCL’s offline/local operations:

AreaOperations
AccountCreate accounts, derive keys, export public/private keys, sign transactions
AddressParse, validate, convert between bech32 and bytes
CryptoBlake2b hashing, mnemonic generation/validation, Ed25519 sign/verify
TransactionSerialize, deserialize, hash, sign transactions
PlutusPlutusData CBOR/JSON conversion, datum hashing
ScriptNative script parsing, script hashing
GovernanceDRep, committee cold/hot key derivation
HD WalletCreate wallets, derive addresses
QuickTxTxPlan YAML-driven offline transaction builder: payments, staking, governance, Plutus scripts, multi-party compose

Backend/HTTP modules (Blockfrost, Koios, Ogmios) are intentionally excluded from the native library — every language has good HTTP clients, and each wrapper ships optional provider helpers instead.

The four wrappers

Section titled “The four wrappers”

All four wrappers are first-class and kept at strict parity — same API groups, same error codes, same TxPlan format — differing only in language idiom:

LanguageGuidePackage
JavaScript (Bun)docs@bloxbean/cardano-client-lib (npm)
Godocsgithub.com/bloxbean/cardano-client-bindings/wrappers/go
Rustdocscardano-client-lib (crate, imported as ccl)
Pythondocscardano-client-lib (PyPI, imported as ccl)

How big is it?

Section titled “How big is it?”

The native library is a ~50–60 MB platform-specific binary (the embedded Scalus UPLC evaluator for offline Plutus costing accounts for ~12 MB of that). Wrapper packages that bundle it (Python wheels, npm platform packages) are correspondingly large; Go and Rust fetch it once and cache it. See Platforms & Packages for the full story, and Caveats & Limitations before relying on specific functions.

Where to next

Section titled “Where to next”