How to Build on Humanode EVM Using thirdweb SDK

Humanode Core -

If you’ve been thinking about building something on Humanode, maybe a game, a token, a small tool, or a dApp with real users, this is probably the easiest way to start.

Until now, building on Humanode meant setting things up from scratch. Not hard, but not exactly beginner-friendly either. Now that thirdweb SDK supports Humanode EVM, things have changed.

You can spin up a project, deploy contracts, connect wallets, and build out your app, all using the tools you’re already familiar with. And since you’re building on Humanode, you get Sybil resistance out of the box. No KYC, no weird data collection. Just proof that your users are real, unique humans.

In this guide, we’ll walk you through how to start building on Humanode using thirdweb. Step by step. No prior Solidity experience needed. Just code, deploy, and experiment.

Let’s take it from the top. 

Setting Up Your Project

Let’s start from scratch.

If you haven’t used thirdweb before, you don’t need to install anything globally, but you will need to run their CLI tool. To do that, just open your terminal and run:

npx thirdweb create app

The first time you do this, it’ll prompt you to install the thirdweb CLI. Go ahead and confirm. Once installed, it’ll walk you through creating your app.

You’ll be asked to pick a framework (like React or Next.js) and a name for your project. If you’re new to this, just pick React and continue.

Once that’s done, it’ll set up a project folder for you with everything ready to go: thirdweb SDK, project structure, and a basic frontend you can start editing right away.

From there, you can open the folder in your code editor and run the app locally.

Next up, we’ll connect your app to the Humanode EVM chain so it actually knows which network it’s talking to.

Connecting to Humanode EVM

By default, the app is set up without any specific blockchain network. If you want everything in your app to use the Humanode EVM chain, you’ll need to pass the chain config into the ThirdwebProvider.

Here’s what to do.

Step 1: Update your layout.tsx file

Open layout.tsx and update your ThirdwebProvider to include activeChain. You’ll also need to define the Humanode chain config manually.

Here’s the full working example:

import {
	DarkTheme,
	DefaultTheme,
	ThemeProvider,
} from "@react-navigation/native";
import { useFonts } from "expo-font";
import { Stack } from "expo-router";
import * as SplashScreen from "expo-splash-screen";
import { useEffect } from "react";
import { ThirdwebProvider } from "thirdweb/react";
import { useColorScheme } from "@/hooks/useColorScheme";
import { StatusBar } from "react-native";
import { Colors } from "../constants/Colors";
// Prevent the splash screen from auto-hiding before asset loading is complete.
SplashScreen.preventAutoHideAsync();
// Humanode chain config
const humanodeChain = {
	chainId: 5234,
	rpc: ["https://rpc.mainnet.stages.humanode.io"],
	nativeCurrency: {
		name: "Humanode",
		symbol: "eHMND",
		decimals: 18,
	},
	name: "Humanode",
	shortName: "humanode",
	slug: "humanode",
	testnet: false,
};
export default function RootLayout() {
	const colorScheme = useColorScheme();
	const [loaded] = useFonts({
		SpaceMono: require("../assets/fonts/SpaceMono-Regular.ttf"),
	});
	useEffect(() => {
		if (loaded) {
			SplashScreen.hideAsync();
		}
	}, [loaded]);
	if (!loaded) {
		return null;
	}
	return (
		< ThirdwebProvider activeChain={humanodeChain}>
			
				< StatusBar
                    backgroundColor={ Colors.dark.background}
    				barStyle=" light-content"
				/>
				< Stack>
					
					< Stack.Screen name=" +not-found" />
				< /Stack>
			< /ThemeProvider>
		< /ThirdwebProvider>
	);
}

Step 2: Done

That’s it. Your app is now fully configured to interact with Humanode EVM. All contract interactions, wallet connections, and reads/writes will use Humanode’s RPC.

If you’d like to go deeper, here’s the thirdweb React Native SDK documentation.

Now that you have connected to the Humanode EVM, you can visit thirdweb documentation to add already built-in functions in your app. thirdweb has an advanced documentation to help developers deploy an app on any EVM chain from scratch.

thirdweb portal

Adding the thirdweb Client

Before your app can talk to thirdweb’s infra (wallets, contracts, etc.), you need to create a thirdweb client with your unique clientId. This tells the SDK who you are and enables secure access to thirdweb’s services.

Step 1: Get your client ID

  1. Go to the thirdweb dashboard.
  2. Sign in and click on Projects.
  3. Create a new project (or use an existing one).
  4. Make sure localhost is in the allowed domains if you’re testing locally.
  5. Copy the Client ID.

Step 2: Set up your .env file

In the root of your project, create a .env file (or rename .env.example if it’s already there), and add this line:

NEXT_PUBLIC_THIRDWEB_CLIENT_ID=your-client-id-here

Replace your-client-id-here with the actual ID from the dashboard.

Step 3: Create the client file

Now, create a new file at the root of your project, ideally:

client.ts

Inside that file, paste:

import { createThirdwebClient } from "thirdweb";

export const client = createThirdwebClient({

  clientId: process.env.NEXT_PUBLIC_THIRDWEB_CLIENT_ID,

});

This creates a reusable client object that you’ll import whenever you need to do something like connect a wallet, read from a contract, or access smart account features.

Step 4: Use the client in ThirdwebProvider

Now go back to your layout.tsx file and update your ThirdwebProvider to use the client.

Update the import and provider like this:

import { client } from "../client"; // adjust path if needed

< ThirdwebProvider client={client} activeChain={humanodeChain}>
  ...

< /ThirdwebProvider>

Now your app is correctly authenticated with thirdweb services and connected to the Humanode EVM chain.

Next, we’ll look at how to deploy a contract using the thirdweb dashboard,  no code, no Solidity,  and then interact with it from your app.

As an example, we’ll try deploying a smart contract using thirdweb’s dashboard, so you can start interacting with it right from your app.

Deploying a Smart Contract (No Solidity Needed)

You don’t need to touch Solidity or even open up a code editor to deploy your first contract on Humanode. thirdweb offers a full-featured dashboard that allows you to deploy all the essentials, including tokens, NFT collections, marketplaces, and more, in just a few clicks.

Here’s how you do it:

Step 1: Open the thirdweb Dashboard

Head over to the thirdweb dashboard. Log in with your wallet if you haven’t already.

Step 2: Create or Select a Project

Find your project or create a new one. Projects help you keep your deployments organized and give you access to features like analytics and gas settings.

Step 3: Choose and Deploy a Prebuilt Contract

Click “Deploy Contract.” You’ll see a list of prebuilt contracts for things like:

  • ERC-20 tokens (for your own cryptocurrency)
  • ERC-721 or ERC-1155 (for NFT drops or collections)
  • Marketplaces (for buying and selling NFTs)

Pick the contract type that fits what you want to build.

You’ll be asked to select the network; choose Custom Network and fill in the Humanode RPC info:

Network Name: Humanode
Chain ID: 5234
RPC URL: https://rpc.mainnet.stages.humanode.io
Currency Symbol: eHMND

Once you fill that out, connect your wallet, customize the contract parameters (like name, symbol, etc.), and hit “Deploy.” After a short wait, your contract is live on Humanode.

Step 4: Copy the Contract Address

Once deployed, the dashboard will show you the contract address. You’ll use this address to connect your mobile app to your new contract.

Step 5: Use the Contract in Your App

Now that you have a contract address, you can interact with it directly from your React Native app using the thirdweb SDK.

Here’s a real example for fetching NFTs from a contract:

import { useContract, useNFTs } from "thirdweb/react";
const { contract } = useContract("your-humanode-contract-address");
const { data: nfts } = useNFTs(contract);

Replace "your-humanode-contract-address" with the address you just deployed.

If you want to explore what’s possible or see what prebuilt contracts are available, check out the thirdweb prebuilt contracts documentation.

In the next section, we’ll dive into how to read from and write to your contract in your app, so you can actually mint tokens, transfer assets, or do whatever your dApp needs to do.

Interacting with Contracts

Now that you’ve deployed your contract and added its address to your app, it’s time to actually use it. This is where the thirdweb SDK shines. You don’t have to mess with ABI files or raw blockchain calls. Instead, you can use simple hooks that take care of all the heavy lifting.

If you want to let users claim NFTs, mint tokens, or transfer assets, there are ready-made hooks for that. All you do is call the hook, pass in the right parameters, and your app is talking to the contract.

Here are a few common examples:

Claiming an NFT

import { useContract, useClaimNFT } from "thirdweb/react";
const { contract } = useContract("your-humanode-contract-address");
const { mutate: claimNFT, isLoading, error } = useClaimNFT(contract);
const handleClaim = async () => {
  await claimNFT({ to: "0x...", quantity: 1 });
};

Minting a Token

import { useContract, useMintToken } from "thirdweb/react";
const { contract } = useContract("your-humanode-contract-address");
const { mutate: mintToken } = useMintToken(contract);
const handleMint = async () => {
  await mintToken({ to: "0x...", amount: 100 });
};

Transferring a Token

import { useContract, useTransferToken } from "thirdweb/react";
const { contract } = useContract("your-humanode-contract-address");
const { mutate: transferToken } = useTransferToken(contract);
const handleTransfer = async () => {
  await transferToken({ to: "0x...", amount: 50 });
};

Each hook handles everything for you, connecting to the contract, sending the transaction, waiting for confirmation, and catching errors.

If you want to see all available hooks or dive deeper into what you can do, check out the thirdweb React SDK Hooks documentation.

In the next section, we’ll look at how to set up wallet connections and authentication, so your users can sign in and interact with your dApp on Humanode.

Adding Wallet Connect and Authentication

For your users to do anything on your dApp, mint, claim, vote, whatever, they’ll need a wallet. With thirdweb, adding wallet support is about as easy as it gets. You just drop in a single component, and users can connect using in-app wallets, MetaMask, or social logins.

Here’s how you do it.

Add a Wallet Connect Button

In your React Native app, you can import and use the ConnectWallet component. Just place it wherever you want users to connect their wallets.

import { ConnectWallet } from "thirdweb/react";
function MyScreen() {
  return (
    
  );
}

This gives users an easy way to connect their wallet right inside your app.

Adding Authentication

If you want your dApp to recognize users (for example, so they can have a profile, save progress, or access restricted features), you can set up authentication using thirdweb Auth. This lets users sign in using their wallet, no emails or passwords needed.

Setting up Auth involves both your app and a small backend server. If you want to go down this path, check out the thirdweb Auth documentation.

In order to check all the features available on thirdweb, you can take a sneek peek or maybe have a little fun:

thirdweb playground.

Connecting Wallets with Humanode Uniqueness

Right now, anyone can connect a wallet. If you want to make sure that only real, unique humans can use your app or claim rewards, you’ll want to combine wallet authentication with Humanode Biomapper.

That’s coming up next. We’ll show how to plug in Biomapper so every wallet in your app becomes truly unique and Sybil-resistant.

Adding Humanode Biomapper for Sybil Resistance

Up to this point, your dApp lets users connect a wallet and interact with your contracts, but that’s not enough if you care about real users and fairness. Anyone can spin up dozens of wallets. To really keep out bots and multi-accounters, you’ll want to integrate Humanode Biomapper.

Biomapper is Humanode’s private biometric verification tool. It doesn’t collect any personal info or KYC, but it ensures that every wallet is tied to a unique, living person. That’s how you get Sybil resistance in your app.

1. Install the Biomapper SDK

First, install the core SDK packages:

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

These include contract interfaces and helper tools for integrating with Biomapper.

Before you integrate Humanode Biomapper into your dApp, you will have to keep in mind that Humanode Biomapper has generations that usually last six months and wipe all the previous users' biomapping data. You can learn more about generation change here: Humanode Biomapper generations.

Remember, this part is important for you to understand how Biomapper works. Below, we’ll add an example of a smart contract on how to use Biomapper.

However, to implement Biomapper into your app, you should read the Humanode Biomapper Documentation to grasp how Biomapper actually works. Humanode Biomapper Documentation. 

2. Write your Smart contract

Write your smart contract to integrate the biomapper into your dApp. Here’s an example smart contract: Sybil-resistant Airdrop

Once you have done all, you will need to test your dApp.

Testing and Deploying Your Sybil-Resistant dApp

Now that you’ve wired up your app to Humanode, deployed your contract, and added real Sybil resistance with Biomapper, it’s time to see it in action.

Here’s how you can test and launch your dApp on Humanode EVM.

  1. Fund your wallet with eHMND
  2. Deploy your smart contract
  3. Test your app.

Once your dApp is up, your contract is live, and biomapping is working, you’re not just ready to launch, you’re actually in the running for something bigger.

Here’s the deal: Humanode has set up a $10 million Ecosystem Funding Program to back real, Sybil-resistant consumer dApps on its chain. If you want more than just tech bragging rights, this is where you go next.

But there are a couple of rules:

  • You have to use Biomapper. No Biomapper, no shot at funding. The whole point is to prove you can build something for real, unique humans, not just a pile of wallets.
  • Your project also needs to pass a few criteria: think growth potential, something new or different, and, of course, being built for actual people, not bots.

The funding isn’t just a handout. The Humanode team will actually work with you, provide tech help, launch support, fundraising advice, and all that. And since they’re serious about not spreading themselves thin, the program is capped at five projects at a time. Right now, there are two slots remaining.

If you’re building something that fits, and you’re serious about using Biomapper, go pitch your project. You can find the details and apply at the incubation website.