Sign in Subscribe
Biomapper

How to Add Sybil Resistance to Your Avalanche dApp with Humanode Biomapper

Humanode Core

• 6 min read
How to Add Sybil Resistance to Your Avalanche dApp with Humanode Biomapper

If there’s one thing Web3 devs can agree on, it’s that Sybils suck. Bots and fake accounts are ruining airdrops, gaming economies, DAOs, and DeFi incentives. Everyone’s trying to fight them, but the solutions are either too centralized and non-private (KYC) or too easy to game (staking-based anti-Sybil tricks).

That’s why Humanode Biomapper was built – an on-chain tool that links one evm account to one human for verifying that users are real, unique humans without KYC or exposing personal data. But there was one problem: it was only available on the Humanode Chain.

And buidlers? They wanted it everywhere.

Over the past year, DeFi teams, DAOs, Web3 games, and NFT projects have been knocking on Humanode’s door, asking:

  • “Hey, when will Biomapper be available cross-chain?”
  • “Can we use Biomapper for Sybil-resistant airdrops on XYZ L1?”
  • “We need one-person-one-vote governance that actually works.”
  • “Bots are killing our play-to-earn economy – can Biomapper stop them?”
  • “Whales are farming staking rewards with multiple wallets. Can we fix this?”

The answer was always "yes," but the catch was that Biomapper was locked to the Humanode chain. Until now.

If you already know about Biomapper and looking to integrate jump directly to Integrate Humanode Biomapper into Your Avalanche dApp

Biomapper now has cross-chain capability

Now, any dApp on EVM-compatible chains can integrate Humanode Biomapper’s Sybil resistance directly into its smart contracts. That means:

  • Airdrops that don’t get botted.
  • DAOs where one person actually means one vote.
  • Web3 games where only real players can earn rewards.
  • Fair DeFi incentives that multi-wallet setups can’t farm.

Today, we are deploying the Biomapper smart contract on Avalanche C-chain, making it the first non-Humanode chain where Biomapper is deployed. And this is just the beginning. Biomapper is rolling out to more L1s, making Sybil resistance a cross-chain standard.

So if you’re building on Avalanche, it’s time to add unique human verification to your dApp – without KYC, without centralized gatekeeping, and at the same time preserving users’ anonymity.

And the best part? It’s simple and easy. 

We will break down how to integrate Biomapper into your smart contract but before that let’s understand how it works: 

How Biomapper Works (Without Screwing Up Privacy)

Alright, so Biomapper is going cross-chain, with Avalanche C-Chain as the first deployment – but how does it actually work? More importantly, how does it verify that someone is a real human without exposing their real-world identity?

Here’s the TL;DR:

  1. User scans their face using the Biomapper App.
  2. Their biometric data is encrypted inside a Confidential Virtual Machine (CVM) (which means no one – not even Humanode – can see or access it).
  3. A Bio-token is generated and linked to their EVM wallet address.
  4. They bridge their bio-token to the required chain.
  5. When they interact with a dApp, the smart contract checks the Bio-token to confirm they’re a unique person.
  6. Done. No identity leaks, no personal data floating around – just proof that they’re not a bot.

Why This is Different from Other Anti-Sybil Methods

  • No KYC → No passports, IDs, or personal data needed.
  • No staking requirements → You can’t just buy your way past the system.
  • No centralized verification authority → No one controls the user list.
  • Privacy-first → Biometrics are never stored or shared with dApps.

How Projects on Avalanche can Use Biomapper

Once a user is biomapped, any EVM dApp can check their uniqueness with a single smart contract call. That means:

  • Airdrop contracts → Only real humans can claim.
  • DAO voting → One person, one vote. No governance takeovers.
  • Game reward systems → No more multi-account farming.
  • NFT whitelists → Verified users only, without KYC.
  • And many more use cases.

It’s Sybil resistance without the usual headaches. And integrating it into your dApp? That’s easy.

Let’s go step-by-step on how to set it up.

Integrate Humanode Biomapper into Your Avalanche dApp

Getting Started

Before you begin, make sure you're familiar with the core Biomapper concepts, such as:

  • Generations → CVMs with Biomapping data resets periodically.
  • General Integration Flow → Users biomap once, bridge it to the specific chain, and can be verified across dApps.

What You Need to Do

  1. Write a smart contract that interacts with Bridged Biomapper on Avalanche C-Chain.
  2. Add a link to the Biomapper UI on your frontend, so users can complete their biomapping

Installation: Set Up Your Development Environment

Before you begin, install the required Biomapper SDK dependencies.

Install the Biomapper SDK

Humanode Biomapper SDK provides interfaces and useful utilities for developing smart contracts and dapps that interact with the Humanode Biomapper and Bridged Biomapper smart contracts.

It is usable with any tooling the modern EVM smart contract development ecosystem provides, including Truffle, Hardhat, and Forge.

It is open-source and is available on GitHub, you will find the links to the repo, examples, and the generated code documentation below.

Using npm (Hardhat/Node.js projects):

npm install --save @biomapper-sdk/core @biomapper-sdk/libraries @biomapper-sdk/events

Using yarn:

yarn add @biomapper-sdk/core @biomapper-sdk/libraries @biomapper-sdk/events

Using Foundry:

If you're using Foundry, add the Biomapper SDK as a dependency:

forge install humanode-network/biomapper-sdk

These packages allow you to interact with Biomapper smart contracts and APIs.

Smart Contract Development

The next step is to integrate Bridged Biomapper into your smart contract.

Step 1: Import Biomapper Interfaces and Libraries

In your Solidity smart contract, import the necessary interfaces and libraries from the Biomapper SDK.

// Import the IBridgedBiomapperRead interface
import { IBridgedBiomapperRead } from "@biomapper-sdk/core/IBridgedBiomapperRead.sol";

// Import the IBiomapperLogRead interface
import { IBiomapperLogRead } from "@biomapper-sdk/core/IBiomapperLogRead.sol";

// Import the BiomapperLogLib library
import { BiomapperLogLib } from "@biomapper-sdk/libraries/BiomapperLogLib.sol";

These imports provide your smart contract with the necessary functions to verify user uniqueness and access biomapping logs.

Step 2: Use Bridged Biomapper on Avalanche

Since Humanode has already deployed the Bridged Biomapper contract on Avalanche C-Chain, your dApp should interact with it instead of deploying a new Biomapper contract.

Smart Contract Example

pragma solidity ^0.8.0;

// Import the Bridged Biomapper Read interface
import "@biomapper-sdk/core/IBridgedBiomapperRead.sol";

contract MyDapp {
    IBridgedBiomapperRead public biomapper;

    constructor(address _biomapperAddress) {
        biomapper = IBridgedBiomapperRead(_biomapperAddress);
    }

    function isUserUnique(address user) public view returns (bool) {
        return biomapper.isBridgedUnique(user);
    }
}

What this does:

  • Connects your contract to the official Bridged Biomapper contract on Avalanche.
  • Allows your contract to verify if a user has been biomapped and is unique.

To access the contract addresses, APIs, and more information about the particular contracts, functions, and events from the official Biomapper SDK documentation. 

Step 3: Using Mock Contracts for Local Development

For local testing, you can use the MockBridgedBiomapper contract. This allows developers to simulate the integration before deploying to testnet or mainnet.

Example usage:

function generationsBridgingTxPointsListItem(uint256 ptr) external view returns (GenerationBridgingTxPoint memory);

Refer to the Biomapper SDK Docs for technical details on using mock contracts.

Step 4: Calling Biomapper Functions in Your Smart Contracts

Checking User Uniqueness

Before allowing a user to claim rewards or access features, verify whether they have a valid biomapping.

function isUnique(IBiomapperLogRead biomapperLog, address who) external view returns (bool);

If the function returns false, prompt the user to complete the verification process.

Implementing Unique User Verification

Here’s an example smart contract that ensures each user is unique before accessing in-game rewards:

contract UniquePlayerRewards {
    using BiomapperLogLib for IBiomapperLogRead;

    IBiomapperLogRead public immutable BIOMAPPER_LOG;
    IBridgedBiomapperRead public immutable BRIDGED_BIOMAPPER;
    mapping(address => bool) public hasClaimedReward;
    
    event RewardClaimed(address player);

    constructor(address biomapperLogAddress, address bridgedBiomapperAddress) {
        BIOMAPPER_LOG = IBiomapperLogRead(biomapperLogAddress);
        BRIDGED_BIOMAPPER = IBridgedBiomapperRead(bridgedBiomapperAddress);
    }

    function claimGameReward() public {
        require(!hasClaimedReward[msg.sender], "Reward already claimed");
        require(BIOMAPPER_LOG.biomappingsHead(msg.sender) != 0, "User is not biomapped");
        require(BRIDGED_BIOMAPPER.biomappingsHead(msg.sender) != 0, "User is not biomapped on bridged chain");
        
        hasClaimedReward[msg.sender] = true;
        emit RewardClaimed(msg.sender);
    }
}

Frontend Integration

Integrating Biomapper on the frontend is simple – just add a link to the Biomapper App so users can verify themselves.

 < ahref="https://biomapper.hmnd.app" target="_blank">
Verify Your Uniqueness with Biomapper

What this does:

  • Redirects users to the Biomapper App, where they scan their biometrics.
  • Once verified, their wallet is biomapped and linked to their EVM address.

Testing and Rollout

Once you have verified your contract works locally, deploy it to Avalanche C-Chain. 

Summing Up

With Humanode Biomapper live on Avalanche C-Chain, developers now have a privacy-preserving, Sybil-resistant way to verify real users without KYC. Whether for airdrops, DAO governance, gaming, or DeFi, Biomapper ensures fairness by preventing bots and multi-wallet exploits.

Once integrated, your dApp is now protected against Sybil attacks while maintaining user privacy.

To take it further:

  • Get your dApp listed in the Biomapper App by reaching out to Humanode
  • Deploy on other EVM-compatible chains beyond Avalanche
  • Explore Biomapper's cross-chain capability

A more human Web3 is now possible. Start integrating today.

For more details, visit the Biomapper SDK Docs and Biomapper docs.

Sign up for more like this.

Enter your email
Subscribe