Build on Africa's
sovereign blockchain

Quick Start

Connect to Alkebuleum in under five minutes. The network is fully EVM-compatible — any Ethereum tooling (ethers.js, viem, Hardhat, Foundry, Remix) works out of the box.

npm install ethers   # or: npm install viem

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://rpc.alkebuleum.com");

// Verify connection
const block = await provider.getBlockNumber();
console.log("Latest block:", block);

Network Config

All parameters needed to add Alkebuleum Mainnet to any EVM wallet or toolchain.

module.exports = {
  networks: {
    alkebuleum: {
      url: "https://rpc.alkebuleum.com",
      chainId: 237422,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  solidity: "0.8.24"
};

PORA Consensus

Proof of Reputable Authority (PORA) is Alkebuleum's bespoke consensus mechanism — designed for institutional trust, African governance structures, and long-term network integrity.

How PORA works

PORA validators are permissioned participants — governments, foundations, universities, and registered institutions — who stake ALKE and are voted in by the Alkebuleum Council. Unlike proof-of-work, PORA produces no wasted computation. Unlike proof-of-stake, validator selection is bounded by real-world reputation, reducing sybil risk in African institutional contexts.

Working with ALKE

ALKE is the native utility token of Alkebuleum. It is used for transaction fees, smart contract gas, validator staking, governance votes, and network access. There was no ICO or presale.

import { Wallet, parseEther } from "ethers";

const wallet = new Wallet(privateKey, provider);

const tx = await wallet.sendTransaction({
  to: "0xRecipientAddress",
  value: parseEther("10"),  // 10 ALKE
});

await tx.wait(2);  // wait 2 confirmations
console.log("Transfer confirmed:", tx.hash);

Identity & AfPass

Alkebuleum is built around sovereign digital identity. AfPass is the decentralised identity passport layer. DRIS handles institutional document signing and registry. Together they form the trust infrastructure for the network.

On-chain DID format

Alkebuleum uses the did:alke: method. Each DID maps to an Alkebuleum address and a verifiable credential document anchored on-chain.

# Alkebuleum DID method
did:alke:0xYourAlkebuleumAddress

# Example
did:alke:0x3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b

DRIS — Document Registry

DRIS enables governments, universities, and institutions to register, sign, and verify documents on-chain. Verification is fully permissionless — any app can call the DRIS contract to confirm a document's authenticity.

interface IDRIS {
    function verify(bytes32 documentHash)
        external view
        returns (bool valid, address issuer, uint256 timestamp);

    function register(bytes32 documentHash, string calldata metadata)
        external;
}

RPC Reference

Alkebuleum exposes a standard JSON-RPC 2.0 interface compatible with all Ethereum tooling. The endpoint supports both HTTP and WebSocket connections.

{ "jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1 }
// Response: { "result": "0x1a4f6" }

{ "jsonrpc": "2.0", "method": "eth_getBalance",
  "params": ["0xYourAddress", "latest"], "id": 1 }
// Response: { "result": "0x8AC7230489E80000" } (10 ALKE in wei)

Core Protocol Contracts

Alkebuleum ships a set of sovereign identity and naming contracts that any developer can read from, integrate with, or build on top of. These are not third-party libraries — they are the live on-chain infrastructure of the network.

const record = await registry.getRecord("AA00000001");
// { itype: 0, owner: "0x...", controller: "0x...",
//   custodianAIN: "0x00...", status: 0, ... }

const ROLE_DELEGATE = ethers.id("ALKE_ROLE_DELEGATE");
const delegate = await registry.getLinkedAddress(ain, ROLE_DELEGATE);

const [ain, valid] = await registry.resolvePrimaryIdentity(walletAddress);
if (!valid) promptRelink();

interface IAINRegistry {
    function isActive(bytes32 ain) external view returns (bool);
    function controllerToAIN(address ctrl) external view returns (bytes32);
}

contract MyAlkeApp {
    IAINRegistry public immutable registry;

    constructor(address _registry) { registry = IAINRegistry(_registry); }

    modifier onlyVerifiedIdentity() {
        bytes32 ain = registry.controllerToAIN(msg.sender);
        require(ain != bytes32(0), "No AIN");
        require(registry.isActive(ain), "AIN not active");
        _;
    }

    function doSomething() external onlyVerifiedIdentity {
        // caller is a verified, active Alkebuleum identity
    }
}

// 1. Preview the AIN first (no gas)
const [previewAIN, salt] = await registry.findFreeAIN(0, userAddress, 0);

// 2. Register
const tx = await registrar.registerHuman(
  userAddress,   // controller
  ethers.ZeroHash, // metadataDigest (0 = skip)
  salt,          // from findFreeAIN
  ethers.ZeroHash  // custodianAIN (0 = self-sovereign)
);
const receipt = await tx.wait();

const price = await ans.quoteInExtension("alke", 0 /*ANNUAL*/, 1);

await ans.registerForWithExtension(
  "satoshi",       // label
  "alke",          // extension
  0,               // Tier.ANNUAL
  ain,             // AIN to link (bytes32(0) to skip)
  userAddress,     // recipient — owns the NFT
  { value: price }
);

const ain = await ans.resolveWithExtension("satoshi", "alke");
if (ain === ethers.ZeroHash) handleNotFound();

const KEY_WEBSITE = ethers.id("KEY_WEBSITE");
await ans.setRecordWithExtension("satoshi", "alke", KEY_WEBSITE, "https://mysite.com");

// Resolve a .alke name to an identity record
const ain = await ans.resolveWithExtension("satoshi", "alke");

if (ain !== ethers.ZeroHash) {
  const record = await registry.getRecord(ain);
  console.log("Type:",       record.itype);      // 0 = HUMAN
  console.log("Controller:", record.controller);
  console.log("Status:",     record.status);     // 0 = Active
}

Ecosystem SDKs

Alkebuleum's ecosystem products each provide their own SDK and documentation. All run on Alkebuleum and accept ALKE for gas.