Build gates for humans,
not identity databases.

Trust model

Canonical v1 descriptors

Consumers require the hash of an exact canonical string. No spaces or aliases are accepted.

Nationality uses ISO 3166-1 alpha-3 uppercase codes: nationality=ARG, nationality=USA.

Request a v1 attestation

The holder calls the API from the verification app. Before signing, the server verifies the private credential signature and freshness, the subject's live SBT ownership, both contract issuer addresses, and the exact configured chain/verifier pair.

import { predicateContext } from "@ubi2/sdk";

const response = await fetch("https://proofofhumanity.org/api/predicate", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    credential,       // private, holder-controlled v1 credential
    credentialSig,
    predicate: "age>=18",
    consumer: APP_OR_CONTRACT_ADDRESS,
    context: predicateContext("community:season-1"),
    subject: connectedWallet,
    nonce: cryptoNonce.toString(),
    verifier: PREDICATE_VERIFIER_ADDRESS,
    chainId: 84532,
  }),
});

const { attestation, signature } = await response.json();

Read-only verification

import { checkPredicateArtifact } from "@ubi2/sdk";

const result = await checkPredicateArtifact({
  artifact: { chainId, verifier, attestation, signature },
  rpcUrl,
  presenter: connectedWallet,
  consumer: APP_OR_CONTRACT_ADDRESS,
});

if (!result) throw new Error("predicate not satisfied");

Consume v1 atomically on-chain

A state-changing consumer must call consume itself. The verifier requiresatt.consumer == msg.sender, checks subject and freshness, and marks the(subject, consumer, context, nonce) replay key as spent.

interface IPredicateVerifier {
    struct PredicateAttestation {
        address consumer;
        bytes32 context;
        bytes32 predicate;
        bool result;
        address subject;
        uint32 epoch;
        uint256 nonce;
    }

    function consume(
        PredicateAttestation calldata att,
        bytes calldata signature,
        address presenter
    ) external returns (bool result);
}

bytes32 constant AGE_18 = keccak256("age>=18");

function join(
    IPredicateVerifier.PredicateAttestation calldata att,
    bytes calldata signature
) external {
    require(att.consumer == address(this), "wrong consumer");
    require(att.context == keccak256("community:season-1"), "wrong context");
    require(att.predicate == AGE_18 && att.result, "18+ required");
    require(verifier.consume(att, signature, msg.sender), "not eligible");
    _addMember(msg.sender);
}

Release network

Quick Launch exposes only Base Sepolia and only when both contract addresses are configured.

Security checklist

• Require the exact descriptor hash, result == true, consumer, context, and subject your action expects.
• Use consume inside state-changing flows; use check only when replay is harmless.
• Never accept a chain ID or verifier address that is not in your own allowlist.
• Keep the issuer key server-side in an HSM or managed signer; never expose it as NEXT_PUBLIC_*.
• Keep owner and issuer roles distinct: owner is the governance multisig; issuer is the narrow operational signer.
• Do not log held credentials, Self proof payloads, passport attributes, or issuer secrets.
• Reject every non-Base-Sepolia chain and require PredicateVerifier.prover() == address(0).