HeLa Testnet: A Developer's Getting-Started Guide

HeLa testnet has been running for several weeks. The first on-chain identity was minted in early April; the EIP-7951 P-256 precompile went live shortly after. If you have been watching from the sidelines, this is a practical guide to what is actually deployed, how to connect, and what is worth experimenting with today.

What Is Live on Testnet

Three features are active and testable right now.

1. P-256 Signature Verification (EIP-7951)

The EIP-7951 precompile lets EVM contracts verify secp256r1 (P-256) signatures — the same curve used by FIDO2 / WebAuthn passkeys and hardware security keys. On HeLa testnet, this operation costs approximately 3,450 gas, an 87× reduction versus equivalent software implementations.

What that means in practice: a smart contract can check "did the user's phone hardware sign this message" in a single EVM call, cheaply enough to be economical in an account abstraction validation step.

2. Token-Bound Accounts / Citizen ID (ERC-6551)

ERC-6551 lets any NFT own a smart contract account. HeLa uses this as the foundation for Citizen ID: each identity is an NFT, and the bound account acts as the user's on-chain wallet and identity root. The first Citizen ID was minted on the HeLa testnet in April 2026.

Because the bound account is itself an ERC-4337 smart account, the system can sponsor gas at mint time — users get an on-chain identity without ever holding ETH or native tokens first.

3. ERC-4337 Account Abstraction

ERC-4337 account abstraction is live and used for Citizen ID minting. The UserOperation flow (bundler → EntryPoint → account) runs on testnet. You can deploy your own smart accounts, use paymasters to sponsor gas, and write custom validation logic that calls the P-256 precompile.

---

Connecting

HeLa is EVM-compatible. Any Ethereum tooling — Hardhat, Foundry, ethers.js, viem, MetaMask — works without modification.

The testnet chain ID is 666888. Add it to your wallet or Foundry config the same way you would any EVM-compatible network. For the current RPC endpoint, faucet, and block explorer URL, see the HeLa developer documentation (or ask in the developer Telegram).

# Foundry — deploy to HeLa testnet
forge create src/MyContract.sol:MyContract   --rpc-url $HELA_TESTNET_RPC   --private-key $DEPLOYER_KEY   --chain-id 666888

// ethers.js — connect
const provider = new ethers.JsonRpcProvider(process.env.HELA_TESTNET_RPC);
const network = await provider.getNetwork();
console.log(network.chainId); // 666888n

---

Three Experiments Worth Running

Experiment 1: Call the P-256 Precompile Directly

The precompile accepts a packed ABI-encoded payload: (message_hash, r, s, x, y) — the 32-byte hash of the signed message followed by the four 32-byte components of the ECDSA signature and public key.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract P256Verify {
    // EIP-7951 precompile address on HeLa testnet
    address constant P256_PRECOMPILE = 0x0000000000000000000000000000000000000100;

    function verify(
        bytes32 msgHash,
        bytes32 r,
        bytes32 s,
        bytes32 x,
        bytes32 y
    ) external view returns (bool) {
        bytes memory input = abi.encodePacked(msgHash, r, s, x, y);
        (bool success, bytes memory result) = P256_PRECOMPILE.staticcall(input);
        return success && result.length > 0 && result[31] == 0x01;
    }
}

Generate a test signature with any WebAuthn library or the Web Crypto API using { name: "ECDSA", hash: "SHA-256" } on the P-256 curve. Pass the components into your contract and confirm the return value is true. At current testnet gas costs, the staticcall runs for ~3,450 gas.

Experiment 2: Deploy a Token-Bound Account

The ERC-6551 reference registry is the standard deployment point. Once you have an NFT, calling createAccount on the registry returns the deterministic address of its bound account — even before the account is deployed. You can send assets to that address immediately and deploy the account later.

const registry = new ethers.Contract(ERC6551_REGISTRY, registryAbi, signer);

// createAccount(implementation, salt, chainId, tokenContract, tokenId)
const tx = await registry.createAccount(
  IMPLEMENTATION_ADDRESS,
  ethers.ZeroHash,          // salt
  666888n,                  // HeLa testnet chain ID
  MY_NFT_CONTRACT,
  tokenId
);
const receipt = await tx.wait();
console.log("Bound account deployed:", receipt.logs[0].address);

Experiment 3: Submit a UserOperation via ERC-4337

ERC-4337 introduces a parallel mempool for UserOperation objects. The workflow: build a UserOperation, sign it with your account key (or a P-256 passkey via the precompile), send it to a bundler, and the bundler submits it through the EntryPoint contract.

The permissionless.js library makes this straightforward:

import { createSmartAccountClient } from "permissionless";
import { toSimpleSmartAccount } from "permissionless/accounts";

const account = await toSimpleSmartAccount({
  client: publicClient,
  owner: walletClient,
});

const smartAccountClient = createSmartAccountClient({
  account,
  chain: { id: 666888, name: "HeLa Testnet" },
  bundlerTransport: http(process.env.HELA_BUNDLER_URL),
});

const txHash = await smartAccountClient.sendTransaction({
  to: "0xRecipient",
  value: parseEther("0.001"),
});

The interesting path: replace the owner with a P-256 validator that calls the EIP-7951 precompile in its validateUserOp hook. That gives you passkey-authenticated gasless transactions in ~50 lines of Solidity.

---

Current Status

All three features are testnet-only. Mainnet activation is pending final polish items tracked by the security team. The testnet has been stable enough for development and integration testing since early April.

If you find unexpected behavior, the best place to report it is the developer Telegram. Seth's team reviews all testnet findings — credible bug reports feed directly into the mainnet readiness checklist.

Next Steps

• HeLa developer documentation — RPC endpoint, faucet, block explorer
• EIP-7951 — P-256 precompile specification
• ERC-6551 — token-bound accounts
• ERC-4337 — account abstraction
• permissionless.js — ERC-4337 tooling
• FIDO2 WebAuthn spec — passkey credential format

The testnet is open. Chain 666888 is waiting.