> ## Documentation Index
> Fetch the complete documentation index at: https://docs.notareum.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

# SDK Overview

Notareum ships three first-class SDKs that expose the same protocol surface: TypeScript, Python, and Rust. Each SDK wraps the same set of deployed smart contracts (`NotaRegistry`, `VerificationEngine`, `ValidatorStaking`, `NOTAToken`, `veNOTA`, `FeeManager`, `SlashingManager`, `AccessManager`) behind a unified `Notareum` factory that exposes six sub-clients.

## At a glance

| SDK        | Package         | Runtime                           | Tests       | Status |
| ---------- | --------------- | --------------------------------- | ----------- | ------ |
| TypeScript | `@notareum/sdk` | Node.js 20+, browsers (ESM)       | 159 passing | Stable |
| Python     | `notareum`      | Python 3.10+                      | 189 passing | Stable |
| Rust       | `notareum`      | Rust edition 2021 (stable), Tokio | 127 passing | Stable |

All three SDKs implement:

* `.nota` file creation, signing, parsing, validation, and serialization (off-chain, no gas).
* On-chain resource registration, alias resolution, and revocation via `NotaRegistry`.
* Verification request and attestation flows via `VerificationEngine`.
* Validator staking, unstaking, and tier queries via `ValidatorStaking`.
* veNOTA governance locks and voting power queries via `veNOTA`.
* Fee configuration reads and governance-only writes via `FeeManager`.

## Feature matrix

| Capability                    |     TypeScript     |              Python             |             Rust             |
| ----------------------------- | :----------------: | :-----------------------------: | :--------------------------: |
| `.nota` create / sign / parse |          ✓         |                ✓                |               ✓              |
| Fluent builder API            |          ✓         |                ✓                |               ✓              |
| Resource registration         |          ✓         |                ✓                |               ✓              |
| Alias resolution              |          ✓         |                ✓                |               ✓              |
| Verification requests         |          ✓         |                ✓                |               ✓              |
| Attestation submission        |          ✓         |                ✓                |               ✓              |
| Staking + tiers               |          ✓         |                ✓                |               ✓              |
| veNOTA governance             |          ✓         |                ✓                |               ✓              |
| Fee reads                     |          ✓         |                ✓                |               ✓              |
| Async transport               |   native Promise   |       sync + async helpers      |        native `tokio`        |
| Strong typing                 |  TypeScript types  | Python type hints + dataclasses |     `serde` + `thiserror`    |
| Minimum toolchain             | Node 20, ethers v6 |      Python 3.10, web3.py 7     | Rust edition 2021, ethers v2 |

## Choosing an SDK

**TypeScript (`@notareum/sdk`).** The right choice for web dApps, wallets, browser extensions, and any Node.js backend. Integrates with `ethers` v6 providers and signers. Tree-shakeable ESM build, works in modern browsers, and ships with full `.d.ts` declarations.

**Python (`notareum`).** The right choice for backend services, data pipelines, Jupyter notebooks, off-chain indexers, and institutional treasury tooling. Built on `web3.py`, integrates naturally with `eth_account`, `pandas`, and FastAPI/Django stacks.

**Rust (`notareum`).** The right choice for high-throughput validator nodes, indexers, embedded agents, and any service where a native compiled binary is preferred. Built on `ethers` v2 and `tokio`, published as a single crate on crates.io. Suitable for WebAssembly targets with minor feature adjustments.

All three SDKs produce byte-identical `.nota` signatures and byte-identical resource IDs for the same inputs. You can create a `.nota` in Python on a backend, ship it to a browser, and verify it in TypeScript without any conversion.

## Entry points

```ts theme={"system"}
// TypeScript
import { Notareum } from "@notareum/sdk";
const ntm = Notareum({ provider, signer, contracts });
```

```python theme={"system"}
# Python
from notareum import Notareum
ntm = Notareum(provider=w3, contracts=addresses, account=acct)
```

```rust theme={"system"}
// Rust
use notareum::Notareum;
let ntm = Notareum::new(config)?;
```

Each sub-client is reachable as a public field: `ntm.nota`, `ntm.registry`, `ntm.verification`, `ntm.staking`, `ntm.governance`, and `ntm.fee`.

See the language-specific Getting Started pages to install and make your first call:

* [TypeScript Getting Started](typescript/getting-started.md)
* [Python Getting Started](python/getting-started.md)
* [Rust Getting Started](rust/getting-started.md)