Five lines.
Every dApp on Solana.

Drop in <EntrosVerify /> for the five-line path, or wire the Pulse SDK for custom UX. Reading on-chain verification state is free and needs no account.

View on GitHub Try the demo

$npm install @entros/verify # or @entros/pulse-sdk for programmatic UX

Five lines. One component.

Render `<EntrosVerify>` as a button in your React tree. The component handles the wallet popup, behavioral capture, on-chain transaction, and callback.

01Recommended

Drop-in component

The popup hosts the wallet connection, three paired rounds (one word and one short path per round), the proof, and the chain submit. Your app stays wallet-adapter-free until the callback fires.

$ npm install @entros/verify

import { EntrosVerify } from '@entros/verify';
<EntrosVerify
  integratorKey="my-app"
  onVerified={(result) => console.log(result)}
/>

Custom UX. Full control.

Own the capture canvas, inline rather than popup. Each verification produces a Groth16 proof, an on-chain Anchor, a Trust Score that builds across re-verifications, and a best-effort SAS attestation.

Wallet-connected verification

The user pays the configured protocol fee and signs one on-chain transaction. The transaction mints or updates the Anchor and recalculates Trust Score. The SDK then attempts a separate, best-effort SAS attestation that can require a message signature.

"use client";
import { useRef } from 'react';
import { useWallet, useConnection } from '@solana/wallet-adapter-react';
import { PulseSDK } from '@entros/pulse-sdk';
const pulse = new PulseSDK({ cluster: 'devnet' });
export function CustomVerify() {
  const touchRef = useRef<HTMLDivElement>(null);
  const { wallet } = useWallet();
  const { connection } = useConnection();
  async function handleVerify() {
    const result = await pulse.verify(
      touchRef.current,
      wallet?.adapter,
      connection,
    );
    if (result.success) console.log(result);
  }
  return (
    <>
      <div ref={touchRef} className="capture-canvas" />
      <button onClick={handleVerify}>Verify</button>
    </>
  );
}

$ npm install @entros/pulse-sdk

Query on-chain state.

This is what your integration reads. Paste any wallet address to see its verification status, Trust Score, and history from Solana devnet.

Devnet

Check any wallet's verification status on devnet.

Wallet Address

Try with , a verified devnet wallet.

Read. Gate. Display.

Reads are free via verifyEntrosAttestation(). For a high-value action, pair the read with a verification.

Read a wallet's attestation

Read an existing SAS attestation from chain state. No verification UI, API call, or key is required. Pair the read with a fresh verification for higher-value actions.

import { verifyEntrosAttestation } from '@entros/pulse-sdk';
import type { Connection } from '@solana/web3.js';
export async function hasVerifiedAnchor(
  walletAddress: string,
  connection: Connection,
): Promise<boolean> {
  const attestation = await verifyEntrosAttestation(walletAddress, connection);
  return Boolean(attestation?.isHuman && !attestation.expired);
}

Gate access on an Anchor

Drop-in React component. Renders children only when the connected wallet has an Anchor above your Trust Score floor that verified inside your recency window. Source and live preview at /gate-demo, copy the file into your own components folder.

// Copy the EntrosGate source from entros.io/components/ui/entros-gate.tsx
import { EntrosGate } from "./components/EntrosGate";
export function PremiumPage() {
  return (
    <EntrosGate minTrustScore={100}>
      {/* Renders only when the connected wallet has an Anchor
          with trust_score >= 100 on devnet */}
      <h1>Verification policy satisfied.</h1>
    </EntrosGate>
  );
}

Display verification status

Pill component for profiles, comments, leaderboards. Reads the Anchor PDA on each render and shows the current Trust Score. Copy the source from /badge-demo.

// Copy the EntrosBadge source from entros.io/components/ui/entros-badge.tsx
import { EntrosBadge } from "./components/EntrosBadge";
import { useConnection } from "@solana/wallet-adapter-react";
export function ProfileHeader({ walletAddress }: { walletAddress: string }) {
  const { connection } = useConnection();
  return (
    <div className="flex items-center gap-4">
      <h2 className="text-xl font-bold">{walletAddress}</h2>
      <EntrosBadge walletAddress={walletAddress} connection={connection} />
    </div>
  );
}

Display primitives. Live previews.

Copy the source into your Tailwind project. No custom UI dependencies, no Entros backend; each component reads Solana through your wallet connection.

<EntrosBadge />

Pill that displays any wallet's Trust Score, in profiles, comments, or leaderboards.

Live demo · source

<EntrosGate minTrustScore={N}>

Route guard. Wrap any content, set a Trust Score floor and recency window. Handles wallet connection, Anchor lookup, and verification prompts.

Live demo · source

Seven options. Sensible defaults.

Tier 2 only. The drop-in <EntrosVerify /> component takes fewer props: integrator key, cluster, optional Trust Score floor.

Option	Type	Description
cluster	"devnet" \| "mainnet-beta" \| "localnet"	SDK target. Hosted Entros support is devnet-only.
rpcEndpoint	string	Custom RPC URL (optional).
relayerUrl	string	Entros executor endpoint (advanced).
relayerApiKey	string	Executor API key (advanced).
wasmUrl	string	Path to the entros_hamming.wasm artifact.
zkeyUrl	string	Path to the entros_hamming_final.zkey proving key.
threshold	number	Hamming distance threshold (default: 96).

Zero integration cost.

Wallet-connected users pay a small protocol fee per verification (~0.005 SOL). Your application reads on-chain state free via verifyEntrosAttestation(). No escrow, no API keys, no billing relationship.

The first verification also funds account rent for the Anchor mint, token account, and IdentityState account. The wallet shows the total before approval.

Current protocol fees accrue to the treasury. Validator rewards remain a planned mechanism.

Built-in bot resistance.

The validation service evaluates submitted evidence before it reaches the chain. Detection decides whether a capture passes. You set trust requirements through four mechanisms.

Rate limiting

Cap verifications per IP, per session, or per time window before a transaction reaches the chain.

Trust Score thresholds

Require a Trust Score floor and recent verification for protected features. New Anchors start at zero. High-value actions can ask for a fresh verification.

Protocol fee

The fee and rate limits bound request volume.

Closed-source defense layer

Captures pass through a closed-source validation pipeline before reaching the chain. Rejections are uniform across check types, so clients see no per-check signal to calibrate against.

Verified humans.
Free for integrators.

Try the demo See use cases

Five lines.Every dApp on Solana.