npm install @notareum/sdk ethers

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);

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);

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 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())

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()?);