I Built the First Utility Library for GenLayer — Here's What's Inside

genlayer-utils provides reusable patterns to GenLayer Intelligent Contracts. Stop rewriting boilerplate — drop in battle-tested helpers for web access, AI prompts, access control, and more.

Every GenLayer contract I've built starts the same way.

Define an inner function. Call gl.nondet.web.render(). Build a prompt. Call gl.nondet.exec_prompt(). Serialize with json.dumps(sort_keys=True). Wrap everything in gl.eq_principle.strict_eq(). Deserialize the result.

That's 15–20 lines of code. And it's identical in structure across every single contract.

After building TruthPost, a decentralized AI fact-checker, I realized I'd written the same patterns three times in a single project. So I extracted them into a library.

genlayer-utils is the first utility library for GenLayer Intelligent Contracts. It's open source, MIT licensed, and ready to use today.

The Problem

GenLayer is an AI-native blockchain. Contracts can browse the internet and call LLMs natively, no oracles needed. It's genuinely powerful.

But there's a cost: every contract that uses these features repeats the same boilerplate. There are zero reusable libraries in the ecosystem. Every developer starts from scratch.

Here's what a typical web + AI call looks like in a GenLayer contract:

def _fact_check(self, claim_text, source_url):

    def check_claim():

        web_data = gl.nondet.web.render(source_url, mode="text")

        prompt = f"""You are a fact-checker. Based on the evidence,

        determine whether this claim is true or false.

        CLAIM: {claim_text}

        EVIDENCE: {web_data}

        Respond ONLY with JSON: {{"verdict": "<true|false>",

        "explanation": "..."}}"""

        result = gl.nondet.exec_prompt(prompt, response_format="json")

        return json.dumps(result, sort_keys=True)

    raw = gl.eq_principle.strict_eq(check_claim)

    return json.loads(raw)

Now imagine writing this for every method that touches the web or AI. It adds up fast.

The Solution: genlayer-utils

Five modules. Copy what you need. That's it.

1. nondet — Non-Deterministic Block Helpers

The biggest time-saver. Turns the entire web → LLM → consensus pattern into a single function call.

Before (20 lines):

def _check(self, url):

    def _inner():

        data = gl.nondet.web.render(url, mode="text")

        result = gl.nondet.exec_prompt(

            f"Analyze: {data}", response_format="json"

        )

        return json.dumps(result, sort_keys=True)

    return json.loads(gl.eq_principle.strict_eq(_inner))

After (1 line):

result = web_llm_strict(url=url, prompt_template="Analyze: {web_data}")

Three functions cover most use cases:

2. llm — Prompt Templates

Writing prompts that reliably pass strict_eq consensus is tricky. Validators need to independently produce the same output. These templates are pre-optimized for that:

# Classify text into categories

prompt = classify_prompt(

    text="This product is terrible",

    categories=["positive", "negative", "neutral"]

)

result = llm_strict(prompt)

# {"category": "negative", "confidence": "high", "reason": "..."}

# Fact-check a claim against web evidence

prompt = fact_check_prompt(

    claim="Python was created in 1991",

    evidence="{web_data}"

)

result = web_llm_strict(url="https://en.wikipedia.org/wiki/Python", prompt_template=prompt)

# {"verdict": "true", "explanation": "..."}

# Extract structured data from text

prompt = extract_prompt(

    text="John Smith, 32, works at Google",

    fields={"name": "full name", "age": "numeric age", "company": "employer"}

)

# {"name": "John Smith", "age": "32", "company": "Google"}

Four templates: classify_prompt(), fact_check_prompt(), extract_prompt(), yes_no_prompt(). Plus validators to check the LLM's response format.

3. access_control — Owner & Role Guards

GenLayer has no built-in access control. Every contract that needs it checks gl.message.sender_address manually. genlayer-utils provides drop-in guards:

@gl.public.write

def admin_action(self):

    require_sender(self._owner)  # One line. Done.

    # ... only owner reaches here



@gl.public.write.payable

def purchase(self):

    require_value(100)  # Must send at least 100 GEN

    # ... process purchase

Also includes documented patterns for Ownable (single owner) and Role-Based Access (admin, moderator, editor, etc.) that you can copy into your contract.

4. web_oracle — Web Data Extraction

Domain-specific helpers with consensus built in:

# Fetch an asset price from any web source

result = fetch_price(

    url="https://www.coingecko.com/en/coins/bitcoin",

    asset_name="Bitcoin"

)

# {"price": "67500.42", "currency": "USD", "timestamp": "..."}



# Fetch a sports score

result = fetch_score(

    url="https://www.espn.com/match/12345",

    team1="Arsenal", team2="Chelsea"

)

# {"score": "2:1", "winner": 1, "status": "finished"}



# Fetch any JSON API

data = fetch_json_api("https://api.example.com/data")

5. storage — TreeMap & DynArray Helpers

Small but saves repetitive code:

# Before (3 lines)

if sender not in self.reputation:

    self.reputation[sender] = 0

self.reputation[sender] += 10



# After (1 line)

increment_or_init(self.reputation, sender, 10)

Also: treemap_paginate() for paginated views, address_map_to_dict() for converting address-keyed maps, and treemap_count().

Example Contracts

The repo includes 4 complete, deployable contracts that demonstrate the patterns:

Each one is a real contract you can deploy on GenLayer Studio right now.

How to Use

GenLayer contracts run as single Python files inside GenVM. There's no pip install. So you copy the functions you need into the top of your contract:

# { "Depends": "py-genlayer:test" }

import json

from genlayer import *



# ─── genlayer-utils: nondet ─────────────────

def web_llm_strict(url, prompt_template, *, mode="text", response_format="json"):

    # ... (paste from the repo)



# ─── genlayer-utils: llm ────────────────────

def fact_check_prompt(claim, evidence, verdicts=None):

    # ... (paste from the repo)



# ─── Your contract ──────────────────────────

class MyContract(gl.Contract):

    ...

This is how all contract libraries start, even OpenZeppelin began as copy-paste patterns. Zero dependencies, full transparency, and you only include what you use.

What's Next

This is v0.1.0. Here's what I'm planning:

• 
  CLI inject tool - A script that reads # genlayer-utils: nondet, llm directives in your contract and auto-injects the relevant functions before deployment


• 
  More prompt templates - Sentiment analysis, summarization, comparison


• 
  More oracle patterns - Weather, news, social media data extraction


• 
  Community contributions - If you have patterns you reuse, submit a PR

Get Started

git clone https://github.com/luch91/genlayer-utils.git

Browse the source, copy what you need, and start building.

• 
  Repository: github.com/luch91/genlayer-utils
  


• 
  Docs: docs/ folder
  


• 
  Examples: examples/ folder
  


• 
  GenLayer Docs: docs.genlayer.com
  

Built as a contribution to the GenLayer Builder Program. If you're building on GenLayer, I'd love to hear what patterns you need, open an issue or drop a comment below.