HashKey testnet live

Verify humans,
not wallets.not bots.

The trust infrastructure HashKey Chain needs. Zero-knowledge proof verification that lets protocols confirm humans without ever seeing wallet addresses.

npm install @nebulaid/gateway-sdk
Open DemoView on NPM
Verification

140ms

Addresses exposed

0

Sybils blocked

90%+

Live SDK preview

Real request and response.

140ms

createTrustClient

Canonical SDK call.

SDK
import { createTrustClient, HASHKEY_TESTNET, defaultProofLibrary } from "@nebulaid/gateway-sdk"

const client = createTrustClient({
  chainId: HASHKEY_TESTNET.id,
  proofLibrary: defaultProofLibrary,
})

const result = await client.verify({
  wallet: "0x1234...",
  protocol: "vault",
  reputationBand: 4,
  humanProof: true,
})
Privacy-firstNo KYCHashKey testnet

Proof

The landing page should prove the product with specifics.

These metrics are intentionally concrete, because the story only works if the page can be tested by reading it.

Verification time

140ms

Sybil blocked

90%+

Wallet addresses

0 exposed

Integration time

10 min

The Problem

HashKey protocols are flying blind on trust.

Airdrops see 70%+ bot claims. Vaults get drained by sybils with thousands of wallets. The ecosystem needs trust infrastructure—not more KYC surveillance.

01
Broken

KYC

Works, but it destroys privacy and excludes users who should not need to reveal identity.

02
Broken

Gitcoin Passport

Useful, but incomplete and not designed as a protocol-level trust primitive.

03
Broken

Manual review

Too slow for a live DeFi flow and impossible to scale when claims spike.

04
Broken

Token gating

Easy to bypass with multiple wallets and impossible to trust on its own.

What Nebula Gateway adds

The trust infrastructure HashKey Chain needs.

Zero identity leakage—protocols never see wallet addresses. Users prove humanity with Semaphore proofs. On-chain nullifiers stop replay attacks without exposing identity.

Zero wallet address exposure
One SDK, one API call
Built for HashKey Testnet

Use Cases

Built for HashKey DeFi where sybils hurt most.

Every protocol on HashKey Chain faces the same trust gap. Vaults, pools, airdrops, and rewards—all protected by one privacy-preserving infrastructure layer.

90%+ blocked

Airdrop Protection

Verify human proof before token claims so bots and farm wallets do not drain the distribution.

Privacy-firstNo KYCAnti-bot
140ms checks

Vault Access

Gate premium vaults and lending pools by trust band so only verified humans can enter.

Trust bandsHashKeyReal-time
Zero identity leak

Reward Programs

Reward contributors and partners without exposing raw identity, wallet history, or private labels.

Privacy-firstAuditableCohorts
Private membership

Cohort Gating

Create exclusive groups for early supporters, contributors, or partners without tracking them.

ZK proofAccess controlNo tracking

How It Works

Code-first integration from install to nullifier.

The steps are intentionally close to the published SDK so a protocol engineer can read the page and know the integration path immediately.

01

npm install

Install the SDK in your project

npm install @nebulaid/gateway-sdk
02

Initialize Client

Set up the trust client with your config

import { createTrustClient, HASHKEY_TESTNET, DEPLOYED_CONTRACTS, defaultProofLibrary } from "@nebulaid/gateway-sdk"

const trustClient = createTrustClient({
  apiBaseUrl: process.env.NEXT_PUBLIC_API_URL || "http://localhost:3000",
  chainId: HASHKEY_TESTNET.id,
  contracts: DEPLOYED_CONTRACTS,
  proofLibrary: defaultProofLibrary,
})
03

Verify Trust

One API call returns allow, review, or deny

const result = await trustClient.verify({
  wallet: "0x1234...",
  protocol: "vault",
  reputationBand: 4,
  humanProof: true,
  cohortMember: true,
  credentialVerified: true,
  expired: false,
})

console.log(result.decision) // "allow" | "review" | "deny"
04

On-Chain Enforcement

Register nullifier to prevent replay attacks

await writeContract({
  address: DEPLOYED_CONTRACTS.TrustVerifier,
  abi: trustVerifierAbi,
  functionName: "useNullifier",
  args: [normalizeBytes32(proof.nullifier)],
})

Features

Infrastructure that earns its place in every protocol stack.

Every feature is designed for production use on HashKey Chain—from zero-knowledge proof verification to on-chain nullifier registration.

ZK-Proof Identity

Nebula Gateway

Semaphore proofs let users prove trustworthiness without revealing wallet addresses or identity.

Privacy-firstNo KYC

Instant Verification

Nebula Gateway

Browser-generated proofs verify in 140ms through a stable API. No waiting, no complexity.

140msServerless

Policy Engine

Nebula Gateway

Customizable policies return allow, review, or deny. Build your own rules for reputation bands and eligibility.

CustomizableGranular

Audit Trail

Nebula Gateway

Every verification is logged with proof metadata, policy version, and decision reasons.

Full historyCompliance

Drop-in SDK

Nebula Gateway

npm install @nebulaid/gateway-sdk. One API, one decision flow. Integrate in 10 minutes, not weeks.

TypeScriptReact

HashKey Native

Nebula Gateway

Built for HashKey Chain from day one. Deployed on testnet with live contract integration.

DeployedLive

Policy presets

Ready for HashKey DeFi protocols.

Vaults, pools, airdrops, and rewards on HashKey Chain—all using the same trust infrastructure without exposing user identities.

Vault

Premium vaults

Band 4+, Human, Cohort

Pool

Lending pools

Band 3+, Human

Airdrop

Token claims

Band 2+, Human

Rewards

Programs

Band 2+, Credential

Ready for HashKey

Deploy trust infrastructure in ten minutes.

Install the SDK, verify with zero-knowledge proofs, and register nullifiers on HashKey Testnet. The infrastructure your protocol needs is one npm install away.

Open the demoView NPM package
npm install @nebulaid/gateway-sdk