// INTEGRATE

Five lines.
Every dApp on Solana.

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

View on GitHub Try the demo

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

// TIER 1 — DROP-INFASTEST PATH

Five lines. One component.

The fastest path. Render `<EntrosVerify>` as a button anywhere in your React tree—the component handles the wallet popup, the 12-second behavioral capture, the on-chain mint, and hands you a verified payload via callback. Five lines.

01RECOMMENDED

Drop-in component

The popup hosts the wallet connection, the 12-second capture, the proof, and the chain submit. Your app stays wallet-adapter-free until the moment a verified payload arrives on the callback.

$ npm install @entros/verify

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

// TIER 2 — PROGRAMMATIC SDKCUSTOM UX

Custom UX. Full control.

For apps that want to own the verification UX—custom capture canvas, inline rather than popup, branded loading states. Each verification produces a Groth16 proof, an on-chain Anchor, a SAS attestation, and a Trust Score that compounds across re-verifications.

Wallet-connected verification

The user pays a small protocol fee (~0.005 SOL) and signs a single transaction. An on-chain Anchor is minted or updated, a SAS attestation is written, and the Trust Score recomputes—all from one wallet prompt. Your app reads results on-chain for free.

"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) grantAccess(result.commitment);
  }
  return (
    <>
      <div ref={touchRef} className="capture-canvas" />
      <button onClick={handleVerify}>Verify</button>
    </>
  );
}

$ npm install @entros/pulse-sdk

// TRY IT LIVE

Query on-chain identity.

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

// LIVE ON DEVNET

Devnet

Paste any wallet address to check its Entros verification status on-chain.

Wallet Address

Try with —Entros verified wallet on devnet.

// TIER 3 — READ-ONLYGATE OR DISPLAY

Read. Gate. Display.

For apps that read an existing Anchor rather than running the capture. Free reads via verifyEntrosAttestation(), optional copy-source React components for badges and gates. For an action worth the friction, pair it with a verification at the point of the action.

Read a wallet's attestation

Read the SAS attestation from chain state. No verification UI in your app, no API call, no key. Right for display and for lower-stakes gates. Pair it with a verification at the action for anything that moves value.

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>Welcome, verified human.</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>
  );
}

// LIVE DEMOS

Display primitives. Live previews.

Copy the source, paste into your Tailwind project, render anywhere. No custom UI dependencies, no Entros backend. Each component reads directly from Solana via your existing wallet connection.

<EntrosBadge />

Pill that displays any wallet's Trust Score. Use in profiles, comments, leaderboards, anywhere humanness matters.

Live demo · source

<EntrosGate minTrustScore={N}>

Route guard. Wrap any content, set a Trust Score floor and a recency window, and the gate handles wallet connection, identity lookup, and verification prompts.

Live demo · source

// PULSE SDK · CONFIGURATION

Seven options. Sensible defaults.

Tier 2 only. The drop-in <EntrosVerify /> component takes its config from the popup-host and exposes a smaller prop surface (integrator key, cluster, optional trust-score floor).

Option	Type	Description
cluster	"devnet" \| "mainnet-beta"	Solana cluster to connect to.
rpcEndpoint	string	Custom RPC URL (optional).
relayerUrl	string	Entros executor endpoint (advanced; not needed for wallet-connected).
relayerApiKey	string	Executor API key (advanced; not needed for wallet-connected).
wasmUrl	string	Path to entros_hamming.wasm circuit artifact.
zkeyUrl	string	Path to entros_hamming_final.zkey proving key.
threshold	number	Hamming distance threshold (default: 96).

// PRICING

Zero integration cost.

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

First verification additionally requires ~0.013 SOL of one-time Solana account rent for the user's Identity Anchor (mint, token account, identity state). Refundable when accounts are closed. Subsequent verifications cost only the protocol fee plus ~0.002 SOL per new verification record (also refundable).

You get verified humans. The user pays to prove they're human. The protocol gets a recurring fee that funds validator rewards.

// ABUSE PREVENTION

Built-in bot resistance.

Synthetic input is rejected server-side before it reaches the chain. Verification also costs SOL, so Anchors are not free to hold. You control trust requirements through four mechanisms.

Rate limiting

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

Trust Score thresholds

Require a Trust Score floor and a recent verification to reach protected features. New identities start at zero. High-value actions can ask for a verification at the action itself.

Protocol fee

Every verification costs the user SOL, and each wallet carries account rent. Holding many Anchors is not free.

Closed-source defense layer

Captures pass through a closed-source validation pipeline before reaching the chain. Rejection responses are uniform across check types—no per-check signal leaks to clients, denying attackers a directed-calibration channel.

Verified humans.
Free for integrators.

Try the demo See use cases

Five lines.Every dApp on Solana.