UMBR SDK

Private money, as a dependency

One client gives your app or agent private balances, private payments, payroll and proofs on Robinhood Chain and Tempo. Proofs are made where the keys live and checked on-chain. No proving stack for you to run.

Read the SDK guide API reference

Install the SDK

$ pnpm add @umbr/sdk viem

Or try the flow first, with test funds

Open the app on testnet

Pre-release: the package is not on npm yet. The API shown here is the preview and may change.

TypeScriptNode and browserviem

Quickstart

A private payment in a handful of calls

Create a client, shield, send. Your wallet signs every deposit and the SDK never sends a secret off the device. Use the relayer only when you want it.

01Create a clientcreateUmbrClient
02Shield into a private balanceumbr.shield
03Send privatelyumbr.send
04Prove what someone needs to seeumbr.prove

Full walkthrough SDK docs

pay.ts@umbr/sdk · preview

import { createUmbrClient, networks } from "@umbr/sdk";
import { createWalletClient, custom } from "viem";

// Tempo Moderato testnet. Test funds only.
const wallet = createWalletClient({ transport: custom(window.ethereum) });
const umbr = createUmbrClient({ network: networks.tempoModerato, wallet });

// 1. Shield: move public stablecoins into your private balance.
//    The note secret is created and kept on this device.
await umbr.shield({ asset: "pathUSD", amount: "250.00" });

// 2. Send privately to another UMBR address.
//    The proof is made locally; the amount never reaches the explorer.
const receipt = await umbr.send({
	to: "umbr1qexample...recipient", // a private address, not a 0x wallet
	asset: "pathUSD",
	amount: "40.00",
	memo: "Invoice 0192",
});

// 3. Read what is left. Only this client can decrypt it.
const balance = await umbr.balance("pathUSD"); // "210.00"

The whole private flow behind one client

The same core the UMBR app is built on. Plain TypeScript for the browser and for servers, with proving done on the machine that holds the keys.

umbr.shield

Private balance

Shield public stablecoins into a balance that only its holder can read or spend.

umbr.send

Private send

Pay another UMBR address from inside the pool. No public transfer, no visible amount.

umbr.unshield

Unshield

Bring money back to any public wallet whenever it needs to be public again.

relayer: "default"

Optional relayer

Let the relayer submit for you so your wallet is not the sender. It can post or decline, never redirect.

umbr.prove

Prove

Share one fact with one reader, for a set time: a balance floor, a payment, a payroll total.

networks

Two networks, one API

The same calls on Robinhood Chain testnet and Tempo Moderato. Switch the network, keep the code.

For agents

Agents that pay without opening the books

An agent wallet on a public chain is a live feed of what it buys and what it has left. Run the SDK server-side and the agent holds a private balance instead, spends within limits you set, and keeps its keys in your infrastructure.

Its own private balance, funded by a shield from your treasury
Per-payment and per-day limits checked before any proof is made
Payments to vendors without exposing what it buys or how much
Proofs of spend you can hand to whoever audits the agent

Build a private agent Client options

Procurement agent

Pays per request, privately

Testnet

GET
Pricing API
Agent requests a quote
402
Payment required
Vendor names a price and an UMBR address
Paid from its private balance
Within its daily limit
0.25
200
Quote returned
After the vendor saw the payment land

Explorer showsPool transaction

agent.tsserver only

import { createUmbrClient, networks } from "@umbr/sdk";

// A server-side agent with its own private balance and hard limits.
const agent = createUmbrClient({
	network: networks.tempoModerato,
	signer: process.env.AGENT_KEY, // keep it in your secret store
	relayer: "default",
	limits: { perPayment: "2.00", perDay: "50.00" },
});

await agent.send({ to: vendor.umbrAddress, asset: "pathUSD", amount: "0.25" });
// Over a limit? The call throws before any proof is made.

Start building

From install to a private payment in minutes

Follow the quickstart on the testnet: connect a wallet, shield test stablecoins, send privately, then check a proof at the verify page.

Open the quickstart Verify a proof

Docs

SDK guide

Install, configure a client, shield and send.

Docs

API reference

Every call, its options and what it returns.

Docs

Disclosure

Viewing keys and scoped proofs, in code.

Docs

Testnet guide

Networks, test assets and where to get them.

Plain about where it stands

Read the whitepaper Threat model

Testnet only

UMBR runs on Robinhood Chain testnet and Tempo Moderato with test funds. Mainnet pools are not configured yet.

Preview package

@umbr/sdk is not on npm yet and its API may change before the first release. The docs track the current shape.

Not audited

Contracts and circuits have not had an external audit, and testnet proofs use development keys from a single-party setup.