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

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

// 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" \| "localnet"	SDK target. Current hosted Entros support is devnet-only.
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 also funds Solana account rent for the Anchor mint, token account, and identity state. Network rent and transaction fees vary. The wallet displays the final amount before approval.

Integrators receive a public policy signal without an API billing relationship. Current protocol fees accrue to the treasury. Validator rewards remain a planned mechanism.

// ABUSE PREVENTION

Built-in bot resistance.

The validation service evaluates submitted evidence 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

The configured fee and rate limits bound request volume. The validation policy still decides whether a capture passes.

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.