Attestra

The trust layer for NEAR

Facts you can verify.
About anyone, any wallet, any agent.

Attestra turns claims into on-chain attestations with a schema, an issuer and a proof. Check private facts with verifiable AI without revealing them, attest events on other chains without an oracle, and give AI agents an identity and a reputation.

Try it in the sandbox Explore attestationsRead the docs

7

Rust contracts

32

sandbox tools

0

oracles to trust

Attestation

b977586c3a...177118d9

active
Schema
Private AI checkd0d21f...b0fa
Attester
verdicts.attestra.testnet
Subject
attestra.testnet
Issued
Nov 10, 2026, 16:58 UTC
Expires
Nov 10, 2027, 16:58 UTC

Data, decoded from Borsh

rule_id
"age_over_18"
claim
"is at least 18 years old"
result
true
evidence_hash
0x6508e7...3b0f91
model
"z-ai/glm-5.3-flash"

Final on NEAR testnet, block 277,095,095

const r = await client.proveAttestation(uid);
r.data.verified; // true
A private check on testnet, decided in NEAR OutLayer's TEE. Open it in the explorer
Schemas
Attestations
Authorities
Agents

Reading NEAR testnet

Built on NEAR primitives

  • NEAR AI Cloud
  • OutLayer TEE
  • Chain Signatures
  • NEP-413 signatures
  • NEP-366 meta transactions
  • NEP-171 credentials
  • NEP-145 storage
  • NEP-297 events
  • Light client proofs
  • x402 payments
  • Passkeys
  • NEAR Connect

How it works

From a claim to a fact anyone can check.

Four steps, each a contract call you can make from the SDK, the CLI, the MCP server or the sandbox.

  1. 1Step 1

    Define a schema

    Name the fields of a claim once. Its UID is derived from the definition, so anyone can compute it.

    string name, u8 level
  2. 2Step 2

    Attest

    An authority issues a claim about a NEAR account or a wallet on any chain. Delegates, agents and multisigs can issue too.

    attest(schema, subject, data)
  3. 3Step 3

    Resolve

    Resolvers add rules: whitelists, fees, token gates, rewards, or a pipeline of all of them. A refusal rolls everything back.

    pending → created | rejected
  4. 4Step 4

    Verify anywhere

    Read it from the contract, decode it with the SDK, or prove its event is final with a light client proof in the browser.

    isValid(uid) → true

Only on NEAR

What a registry on another chain cannot do.

Each feature uses a NEAR primitive as its core, not as an add-on: verifiable private inference, MPC signatures that read other chains, NEP-413 and NEP-366 for gasless flows, and light client proofs.

How each one works
NEAR AI Cloud, OutLayer TEE

Private facts, checked by verifiable AI

Evidence is encrypted to a NEAR AI Cloud model inside a TEE. A checker (an OutLayer TEE component, or the agent with a bootstrap key in local mode) checks it against the rule and signs a verdict; only its hash goes on chain.

Try it Chain Signatures

Facts about any chain, without an oracle

The NEAR MPC network verifies a transaction on Solana, Base, Arbitrum or Polygon and the contract checks its signature itself.

Try it Function-call access keys

Know Your Agent

Agents get an owner-signed identity, scoped delegation with limits and expiry, and reviews from the people and agents who hired them.

Try it x402, NEP-366, NEP-141

Verification as a paid service

Agents buy "verify a claim" and "check an agent" per call over x402 on NEAR, paying with a signed token transfer and no NEAR for gas.

Try it NEP-413, NEP-366, passkeys

Gasless issuing, passkey subjects

Issuers sign requests and the relayer pays. Subjects with no wallet claim and view credentials with a passkey.

Try it NEP-297, light client proofs

A trustless audit trail

Every change is a NEP-297 event. Prove any of them final with a light client proof checked in your browser: validator signatures and merkle paths, no indexer trust.

Try it

Build with it

One SDK, one CLI, one MCP server.

Every method returns a ServiceResponse and never throws. Every CLI command takes --json. Every read is a tool an agent can call.

  • Credentials from a wallet, a passkey, the NEAR CLI keychain or env
  • One switch between testnet and mainnet across contracts, SDK, CLI and services
  • Storage paid as you go or from a NEP-145 balance someone else funded
  • UIDs computed off chain byte for byte like the contracts
attest.ts
import { AttestraClient, SchemaEncoder } from '@attestra/sdk';

const client = new AttestraClient({ network: 'testnet', accountId, privateKey });

const def = 'string name, u8 level, bool verified';
const { data } = await client.registerSchema({ definition: def, revocable: true });

const encoder = new SchemaEncoder(def);
const att = await client.createAttestation({
  schemaUid: data.schemaUid,
  subject: 'bob.testnet',
  data: encoder.encode({ name: 'Bob', level: 3, verified: true }),
});

// Prove the event is final, checked locally
const proof = await client.proveAttestation(att.data.attestationUid);
console.log(proof.data.verified); // true

Use cases

Trust that other apps can read.

Reputation-gated communities

DAO membership, contributor levels and role credentials that gate access and budgets.

Private eligibility

Over 18, income above a threshold, employed: proven while the document is readable only inside the model TEE.

Contributor credentials

Merged pull requests counted by the checker from GitHub itself, so the claim cannot be faked.

Agent marketplaces

Hire agents by their verified owner, model and reviews; pay them per verification.

Cross-chain receipts

A payment on Base or Arbitrum becomes a NEAR attestation any contract can read.

Organizational issuers

Companies verified by governance, staking for a tier, issuing through employees, bots and 2-of-3 multisigs.

Where it fits

Built for six NEAR Hackathon tracks.

Privacy and Private AI

Facts checked by a NEAR AI Cloud verifiable model in a TEE with end-to-end encryption; only hashes are stored.

Agent Economy

Identity, scoped delegation and reputation for agents, and verification sold per call over x402.

AI Security and Defense

Function-call keys that can only attest and revoke, capped MCP write tools, TEE attestations checked on chain, and reputation before an agent is trusted or paid.

Social Money

Communities that vouch for people: Sputnik DAOs issue membership credentials by proposal and council vote, with token-gated and token-reward resolvers and governance-verified authorities.

NFTs That Do Something

NEP-171 credentials that carry an attestation: non-transferable, minted on request and burned the moment the attestation is revoked.

Open Innovation

Attestations about wallets on any chain, verified by Chain Signatures without an oracle, and light client proofs in the browser.

Issue your first attestation in two minutes.

Sign in with a NEAR wallet or a passkey, register a schema, attest, and prove it final, all on testnet.

Open the sandbox Read the docs