v0.2.41 Released | MIT OR Apache-2.0

One Integration
Manage 15+ Blockchains

A React Native cross-platform wallet core built on Rust. Bridges iOS/Android via UniFFI, providing unified address derivation, transaction signing, and message signing.

Quick Start → View on GitHub

15+ Chains FROST Threshold Offline Signing Production Ready

Supported Blockchains

15 major blockchains, each with an independent Rust adapter crate. Compile on demand without bloating your bundle.

Ethereum

EIP-191/712 EIP-4337 AA EIP-1271

Bitcoin

FROST PSBT Taproot

Solana

SPL Token Versioned Tx Multi-sig

TON

v4r2/v5r1 Jetton TL-B

Sui

Gas Split Object Transfer ed25519

Polkadot

SS58 ed25519 Runtime Meta

Aptos

BCS ed25519 Move

Cardano

Enterprise Addr CBOR ed25519

Cosmos

Protobuf bech32 IBC

NEAR

Implicit Acc borsh SLIP-0010

TRON

TRX/TRC20 Keccak secp256k1

XRPL

Classic Addr secp256k1 rippled

Stellar

XDR StrKey ed25519

Dogecoin

P2PKH Native Meme-ready

StarkNet

ZK-Rollup starknet-core Derivation

Core Features

Not just multi-chain — a systematic design in security, architecture, and engineering.

Unified API Design

All chains follow the same derive → build → sign → inspect lifecycle. Learn once, use everywhere.

Offline Signing

No RPC dependency. Pure local computation. Private keys never leave the Rust layer; JS only handles handles.

FROST Threshold Signing

BTC supports distributed key generation (DKG) and t-of-n threshold signing, powered by the Zcash Foundation frost crate.

PSBT Multi-Sig

Full PSBT build, sign, and verify lifecycle. Supports multi-UTXO and multi-signer orchestration.

Mnemonic Compatible

Standard BIP-39 mnemonic and BIP-44 path derivation. Supports passphrase. Compatible with mainstream wallet recovery.

Feature-gated

Compile only what you need. ETH enabled by default; others controlled via cargo features.

TypeScript Types

Complete type definitions with IDE IntelliSense. Namespace API organization at the RN SDK layer.

Zero Hand-written JNI

UniFFI auto-generates Swift/Kotlin bindings. No hand-written JNI or Objective-C++ glue code.

Architecture

Chain-adapter pattern + UniFFI / WASM bridge. Adding a new chain only requires a new crate — core APIs remain unchanged.

Application Layer (TypeScript)

Namespace API organization (eth.*, btc.*, solana.*) with full TS types. Supports React Native and Browser.

packages/rn-sdk packages/wasm-sdk TypeScript definitions

Bridge Layer

UniFFI auto-generates Swift/Kotlin bindings, WASM via wasm-bindgen for JS

Zero hand-written JNI wasm-bindgen RN / Browser dual platform

Rust Core

Feature-gated chain registry with unified ChainAdapter Trait

crates/ffi crates/chain-registry crates/core

Chain Adapters

15 independent crates, each chain isolated

chain-eth chain-btc chain-solana ... +12 more

$ cargo run -p xtask -- new-chain solana One-command scaffold

Quick Start

Get your first example running in 5 minutes. From install to signing in just a few lines.

npm install @bubolabs/wallet-rn-sdk
cd ios && pod install

import { eth, generateMnemonic } from "@bubolabs/wallet-rn-sdk";

const mnemonic = await generateMnemonic();
const signed = await eth.buildAndSign({
  mnemonic,
  txPayload: JSON.stringify({
    account: 0, index: 0, chain_id: 1,
    gas_price_wei: "1000000000", gas_limit: 21000,
    to_address: "0x1111...1111",
    value_wei: "1000000000000000",
  }),
});
console.log(signed.signedTxHex); // 0xf86c...

import { createBtcFrostDkgSession, runBtcFrostDkgSession } from "@bubolabs/wallet-rn-sdk";

const session = createBtcFrostDkgSession({
  participants: 3,
  threshold: 2,
  network: "mainnet",
  addressType: "p2tr",
});

const result = await runBtcFrostDkgSession(session, {
  round1: async (pkg) => broadcast(pkg),
  round2: async (shares) => collect(shares),
});
// result.groupPublicKey

import { wallets } from "@bubolabs/wallet-rn-sdk";

const candidates = await wallets.importPrivateKey({
  privateKey: "L1aW4a...",
  keyEncoding: "wif",
});
// [{ chainId: "btc", address: "..." },
//  { chainId: "dogecoin", address: "..." }]

npm install @bubolabs/wallet-wasm
# or
yarn add @bubolabs/wallet-wasm

import { init, eth, ton, tron } from "@bubolabs/wallet-wasm";

await init();

const mnemonic =
  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";

const ethWallet = eth.deriveWallet({
  mnemonic,
  account: 0,
  index: 0,
});

const tonAddress = ton.deriveAddress({
  mnemonic,
  account: 0,
  index: 0,
  walletVersion: "v5r1",
});

console.log({ ethWallet, tonAddress });

import { solana } from "@bubolabs/wallet-wasm";

const wallet = solana.deriveWallet({
  mnemonic,
  account: 0,
  index: 0,
});

const signature = solana.signBytes({
  mnemonic,
  account: 0,
  index: 0,
  bytes: "00112233445566778899aabbccddeeff",
  bytesEncoding: "hex",
});

console.log(wallet.address);
console.log(signature.signatureHex);

Security & Trust

Security is not a slogan — it is a concrete choice in every line of code and every design decision.

Key Zero-Exposure

Private keys exist only in Rust heap memory. JS layer handles only handles and signatures, never raw keys.

Zero Network Dependency

Pure offline computation. No embedded RPC nodes. No network leak risk. App layer chooses its own node.

FROST Security

Powered by the Zcash Foundation official frost crate. Nonce Guard prevents replay attacks. Threshold signing eliminates single-point exposure.

API Freeze v1

Public interfaces are locked. Breaking changes require explicit major version bumps. CI auto-checks compatibility.

Deterministic Test Vectors

Every chain has offline test vectors covering signature results, ensuring upgrades do not break existing behavior.

Open Source

Dual-licensed under MIT OR Apache-2.0. Full source on GitHub. Dependencies are all mainstream Rust ecosystem crates.

One Integration Manage 15+ Blockchains

One SDK For Browser & Node