PRIVATUM documentation

Executive summary

Storing crypto today forces an unacceptable compromise. Hot wallets hold your entire private key in one place, so one malware infection drains everything. Hardware wallets cost $150+, run proprietary firmware, and add real friction. Neither gives you privacy: every transaction, balance, and counterparty stays permanently exposed on a public ledger.

PRIVATUM splits the private key mathematically across three independent shards with a 2-of-3 quorum. No single device or server can spend your funds, and transactions are shielded by default. It ships on two surfaces: a cross-platform native desktop app built on Tauri v2 for macOS, Windows and Linux, and @privatumrh/robinhood-chain-sdk, an audited Viem-based TypeScript SDK that lets any developer embed 2-of-3 threshold self-custody.

Why Robinhood Chain

Robinhood Chain is a permissionless, Ethereum-compatible Layer-2 built on Arbitrum Dedicated Blockchains, with ETH as its native gas token. It targets onchain financial infrastructure and tokenized real-world assets while supporting standard EVM tooling and ERC-4337 account abstraction.

The problem

Every existing wallet fails on at least one of three vectors: security, cost and accessibility, or privacy.

What PRIVATUM does

Architecture

PRIVATUM separates core shard and cryptographic lifecycle management from chain-specific execution. Supporting a future L2 or L1 means authoring one adapter: the desktop UI and co-signing infrastructure never change.

User surfaces
  Desktop App (Tauri v2)   |   Open SDK

PRIVATUM Core
  - Shard lifecycle management (Drive / Co-signer / Passkey)
  - Threshold signature orchestration
  - Co-signer protocol & policy enforcement engine

Execution layer
  Robinhood Chain adapter (ERC-4337)  |  DEX aggregation

The shard model

At wallet initialization three shards are generated independently in a secure key-generation ceremony. The full private key is never assembled or stored anywhere.

• Compromise of 1 shard: zero attacker spend authority.
• Loss of 1 shard: complete recovery from the remaining two.
• Non-custodial invariant: PRIVATUM holds exactly one shard, so it never has custody of your assets.

How a transaction signs

1. Build. The desktop app or SDK composes the unsigned payload and generates the signing bytes.
2. Client signs (Shard A). The client decrypts Shard A locally using user credentials and produces the first partial signature.
3. Co-signer signs (Shard B). The partial signature and intent go over TLS to the co-signer API, which authenticates the session, verifies policy constraints such as daily volume and velocity limits, and produces the second partial signature.
4. Combine. The two partial signatures merge mathematically into a single valid aggregate signature.
5. Settle. The transaction is submitted through ERC-4337 bundlers; the smart contract validates the quorum and executes.

Security model

Guarantees are enforced by cryptography and on-chain contracts, not by promises.

Signing relies on partial threshold signature combination and never assembles the private key into memory on a single machine. Client and co-signer environments stay strictly decoupled.

Privacy framework

Privacy is handled in two sequential planes: making the wallet setup indistinguishable on-chain, then keeping financial activity confidential.

Desktop application

Rather than a browser extension or web app, the primary client is a native desktop application engineered with Tauri v2.

PRIVATUM Desktop Application
  Frontend: React / Tailwind UI
  Core backend: Tauri v2 (Rust core)
    - OS keychain / hardware secure storage integration
    - Local AES-GCM encrypted Shard A management
    - Direct RPC & co-signer TLS communication

• Attack surface reduction: immune to extension hijacking, web injection and tab snooping.
• OS-level key storage: Shard A rests in macOS Keychain, Windows Credential Manager or Linux Secret Service.
• Lightweight footprint: native OS webviews instead of a bundled Chromium runtime.
• Full toolkit: send and receive USDG and native ETH, native DEX swaps, shard health monitoring and backup verification, passkey recovery setup and rotation.

The open SDK

@privatumrh/robinhood-chain-sdk is an open-source, Viem-native TypeScript SDK enabling developers to embed PRIVATUM 2-of-3 threshold self-custody and privacy primitives directly into applications on Robinhood Chain (Chain ID: 4663).

bun add @privatumrh/robinhood-chain-sdk viem
# or
npm install @privatumrh/robinhood-chain-sdk viem

10.1 Quick Start: Create and Register Wallet

Generate device Shard A locally and register a deterministic 2-of-3 threshold smart account with the live PRIVATUM co-signer:

import { PrivatumWallet, LocalShard } from "@privatumrh/robinhood-chain-sdk";

// 1. Generate local device key (Shard A)
const shardA = LocalShard.create("device");

// 2. Register wallet with the live PRIVATUM co-signer
const { wallet, shardC } = await PrivatumWallet.create({
  existingShardA: shardA,
});

console.log("Wallet address:", wallet.address);
console.log("Co-signer Shard B address:", wallet.shardB.address);
console.log("Recovery Shard C address:", shardC.address);
console.log("API Key for co-signing:", wallet.apiKey);

10.2 ERC-4337 Threshold Transfers (USDG & Native ETH)

Transfers are executed as ERC-4337 UserOperations. Shard A signs locally and requests a threshold co-signature from Shard B over TLS. Both 65-byte signatures are combined into a 130-byte payload verified by PrivatumAccount.sol:

import { parseEther, parseUnits } from "viem";

// Send native ETH on Robinhood Chain
const ethReceipt = await wallet.sendAsset({
  to: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
  amount: parseEther("0.05"),
  asset: "ETH",
});
console.log("ETH UserOp hash:", ethReceipt.userOpHash);

// Send USDG stablecoin (6 decimals)
const usdgReceipt = await wallet.sendAsset({
  to: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
  amount: parseUnits("25.0", 6),
  asset: "USDG",
});
console.log("USDG UserOp hash:", usdgReceipt.userOpHash);

10.3 Emergency Recovery (Shard C + TOTP 2FA)

If the user loses their primary device, Shard C combines with Co-signer Shard B through standard RFC 6238 TOTP two-factor authentication to rotate Shard A on-chain without revealing private keys:

import { PrivatumWallet, LocalShard } from "@privatumrh/robinhood-chain-sdk";

// Generate replacement device key
const newShardA = LocalShard.create("device");

// Submit recovery rotation signed by Shard C + Shard B
const receipt = await PrivatumWallet.recoverWallet({
  walletAddress: "0xYourWalletAddress",
  shardC: savedRecoveryShardC,
  totpCode: "654321",
  newShardAAddress: newShardA.address,
});
console.log("Recovery UserOp broadcast:", receipt.userOpHash);

10.4 Address Poisoning Sentinel

Prevent users from sending funds to vanity look-alike dust addresses copied from transaction history. The sentinel calculates prefix/suffix edit distances and detects spoofing attempts before Shard A signs:

import {
  checkAddressPoisoning,
  requiresAcknowledgement,
} from "@privatumrh/robinhood-chain-sdk";

const verdict = checkAddressPoisoning({
  recipient: "0x1234c0532925a3b844bc454e4438f44e1234abcd",
  history: [
    {
      type: "send",
      counterparty: "0x123488888888888888888888888888888888abcd",
      amount: "10.0",
      asset: "USDG",
    },
  ],
  ownAddresses: [wallet.address],
});

if (requiresAcknowledgement(verdict)) {
  console.warn("Security Alert:", verdict.title);
  console.warn(verdict.detail);
  console.warn("Look-alike of:", verdict.lookalikeOf);
}

10.5 In-App Spending Guardrails

Client-side financial limits protect against fat-finger errors and unauthorized drainage with 24-hour rolling velocity tracking and configurable strictness:

import {
  evaluateSpend,
  recordSpend,
  loadGuardrailConfig,
  loadSpendingHistory,
  estimateUsdValue,
} from "@privatumrh/robinhood-chain-sdk";

const config = loadGuardrailConfig(wallet.address);
const history = loadSpendingHistory(wallet.address);

const amountUsd = estimateUsdValue("150", "USDG");
const verdict = evaluateSpend(config, amountUsd, history);

if (!verdict.allowed) {
  throw new Error(`Transfer blocked by strict guardrail: ${verdict.message}`);
}

10.6 Disposable Escrow PayLinks

Generate non-interactive, single-use burner payment links that keep primary wallet addresses completely hidden from third parties:

import {
  createPayLink,
  getPayLink,
  checkAndSweepPayLink,
} from "@privatumrh/robinhood-chain-sdk";

// Create shielded paylink
const paylink = await createPayLink({
  senderWallet: wallet.address,
  amount: "50",
  asset: "USDG",
  expiryHours: 24,
  memo: "Invoice #1042",
  singleUse: true,
});

// Check and sweep funds to recipient
const sweep = await checkAndSweepPayLink(paylink.slug);
console.log("Swept:", sweep.swept, "Tx Hash:", sweep.txHash);

Published on npm as @privatumrh/robinhood-chain-sdk. Supports custom co-signer URLs, headers, and pluggable cosign callbacks.

Network & surfaces

Status & roadmap

Path: Robinhood Chain custody → native privacy → multichain. See the roadmap timeline for phase detail.