> ## 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.

# Quickstart

# Quick Start

This guide takes you from zero to a signed, validated `.nota` file in five minutes. We will install the TypeScript SDK, create a file describing an Ethereum wallet, sign it, and validate the round-trip. No on-chain calls are required for the first example.

## Install the SDK

```bash theme={"system"}
npm install @notareum/sdk ethers
```

The Python and Rust SDKs expose the same surface area. See [SDK Overview](../sdks/overview.md) for side-by-side equivalents.

## Create and sign a .nota file

```typescript theme={"system"}
import { Notareum } from "@notareum/sdk";
import { JsonRpcProvider, Wallet } from "ethers";

const provider = new JsonRpcProvider("https://mainnet.infura.io/v3/<key>");
const signer = new Wallet(process.env.PRIVATE_KEY!, provider);

const ntm = Notareum({
  provider,
  signer,
  contracts: {
    notaToken: "0x0000000000000000000000000000000000000000",
    veNota: "0x0000000000000000000000000000000000000000",
    validatorStaking: "0x0000000000000000000000000000000000000000",
    notaRegistry: "0x0000000000000000000000000000000000000000",
    verificationEngine: "0x0000000000000000000000000000000000000000",
    slashingManager: "0x0000000000000000000000000000000000000000",
    feeManager: "0x0000000000000000000000000000000000000000",
    accessManager: "0x0000000000000000000000000000000000000000",
  },
});

const nota = await ntm.nota
  .create({
    type: "address",
    chainId: 1,
    chainName: "ethereum",
    identifier: await signer.getAddress(),
    name: "My Main Wallet",
    alias: "me.nota",
  })
  .sign(signer);

const json = nota.serialize();
console.log(json);
```

The `serialize()` call returns a standards-compliant v1.0 `.nota` JSON document. Save it to a file, send it over a messenger, or encode it into a QR code.

## Parse and validate

```typescript theme={"system"}
import { Notareum } from "@notareum/sdk";

const ntm = Notareum({ provider, contracts: { /* same as above */ } });

const received: string = /* the JSON you received */;
const file = ntm.nota.parse(received);
ntm.nota.validate(file);

console.log("Signer:", file.signature.address);
console.log("Resource:", file.resource.identifier);
console.log("Chain:", file.chain.name, file.chain.chainId);
```

`validate` throws on any schema or signature error. On success, you have a well-formed `.nota` file whose signature matches the claimed address.

## End-to-end flow

```mermaid theme={"system"}
sequenceDiagram
    participant A as Alice
    participant S as SDK
    participant F as .nota file
    participant B as Bob's Wallet

    A->>S: ntm.nota.create(...)
    S->>F: unsigned NotaFile
    A->>S: .sign(signer)
    S->>F: signed NotaFile
    A->>B: send file over any channel
    B->>S: ntm.nota.parse(json)
    S->>B: validate signature
    B->>B: optionally check on-chain status
    B->>A: transaction proceeds
```

## Optional: register and verify on-chain

Registering on-chain anchors the resource in the registry and unlocks validator verification.

```typescript theme={"system"}
await ntm.registry.registerResource(
  0,                                    // resourceType: ADDRESS
  1n,                                   // chainId: Ethereum mainnet
  await signer.getAddress(),
  "0x" + "00".repeat(32),               // proofHash
  "me.nota"
);

const resourceId = ntm.registry.computeResourceId(0, 1n, await signer.getAddress());
await ntm.verification.requestVerification(resourceId, 0);  // BASIC level
```

From here, validators pick up the request and submit attestations. When quorum is reached, the resource becomes `VERIFIED` in the registry.

## Python one-liner

```python theme={"system"}
from notareum import Notareum
from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://mainnet.infura.io/v3/<key>"))
ntm = Notareum(provider=w3, contracts={...})

nota = ntm.nota.create(
    type="address",
    chain_id=1,
    chain_name="ethereum",
    identifier="0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    name="My Main Wallet",
    alias="me.nota",
)
signed = nota.sign(private_key=b"\x01" * 32)
print(signed.serialize())
```

## Rust equivalent

```rust theme={"system"}
use std::sync::Arc;
use notareum::{Notareum, ClientConfig, ContractAddresses, CreateNotaOptions};
use ethers::providers::{Http, Provider};
use ethers::signers::{LocalWallet, Signer};

let provider = Arc::new(Provider::<Http>::try_from(std::env::var("RPC_URL")?)?);
let wallet: LocalWallet = std::env::var("PRIVATE_KEY")?.parse()?;
let private_key_hex = std::env::var("PRIVATE_KEY")?;

let ntm = Notareum::new(ClientConfig {
    provider,
    signer: Some(wallet.clone()),
    contracts: /* ContractAddresses { ... } */,
})?;

let signed = ntm.nota.create(CreateNotaOptions {
    type_: "address".into(),
    chain_name: "ethereum".into(),
    chain_id: 1,
    identifier: format!("{:#x}", wallet.address()),
    name: Some("My Main Wallet".into()),
    alias: Some("me.nota".into()),
    ..CreateNotaOptions::new("address", "ethereum", 1, format!("{:#x}", wallet.address()))
})?
.validate()?
.sign(&private_key_hex)?;

println!("{}", signed.serialize()?);
```

## What to read next

* [Your First .nota File](../guides/your-first-nota-file.md) for a fuller tutorial
* [.nota File Format](../protocol/nota-file-format.md) for the full schema
* [Registering a Resource](../guides/registering-a-resource.md) for the on-chain flow
* [Requesting Verification](../guides/requesting-verification.md) for the validator workflow
* [SDK Overview](../sdks/overview.md) for all three languages