Build GenLayer Intelligent Contracts - Python smart contracts with LLM calls and web access. Use for writing/deploying contracts, SDK reference, CLI commands, equivalence principles, storage types. Triggers: write intelligent contract, genlayer contract, genvm, gl.Contract, deploy genlayer, genlayer CLI, genlayer SDK, DynArray, TreeMap, gl.nondet, gl.eq_principle, prompt_comparative, strict_eq, genlayer deploy, genlayer up. (For explaining GenLayer concepts, use genlayer-claw-skill instead.)
GenLayer enables Intelligent Contracts - Python smart contracts that can call LLMs, fetch web data, and handle non-deterministic operations while maintaining blockchain consensus.
# v0.1.0
# { "Depends": "py-genlayer:latest" }
from genlayer import *
class MyContract(gl.Contract):
value: str
def __init__(self, initial: str):
self.value = initial
@gl.public.view
def get_value(self) -> str:
return self.value
@gl.public.write
def set_value(self, new_value: str) -> None:
self.value = new_value
# v0.1.0
# { "Depends": "py-genlayer:latest" }
from genlayer import *
import json
class AIContract(gl.Contract):
result: str
def __init__(self):
self.result = ""
@gl.public.write
def analyze(self, text: str) -> None:
prompt = f"Analyze this text and respond with JSON: {text}"
def get_analysis():
return gl.nondet.exec_prompt(prompt)
# All validators must get the same result
self.result = gl.eq_principle.strict_eq(get_analysis)
@gl.public.view
def get_result(self) -> str:
return self.result
# v0.1.0
# { "Depends": "py-genlayer:latest" }
from genlayer import *
class WebContract(gl.Contract):
content: str
def __init__(self):
self.content = ""
@gl.public.write
def fetch(self, url: str) -> None:
url_copy = url # Capture for closure
def get_page():
return gl.nondet.web.render(url_copy, mode="text")
self.content = gl.eq_principle.strict_eq(get_page)
@gl.public.view
def get_content(self) -> str:
return self.content
# v0.1.0 (required)# { "Depends": "py-genlayer:latest" }from genlayer import *gl.Contract (only ONE per file)__init__ (not public)@gl.public.view or @gl.public.write| Decorator | Purpose | Can Modify State |
|---|---|---|
@gl.public.view | Read-only queries | No |
@gl.public.write | State mutations | Yes |
@gl.public.write.payable | Receive value + mutate | Yes |
Replace standard Python types with GenVM storage-compatible types:
| Python Type | GenVM Type | Usage |
|---|---|---|
int | u32, u64, u256, i32, i64, etc. | Sized integers |
int (unbounded) | bigint | Arbitrary precision (avoid) |
list[T] | DynArray[T] | Dynamic arrays |
dict[K,V] | TreeMap[K,V] | Ordered maps |
str | str | Strings (unchanged) |
bool | bool | Booleans (unchanged) |
⚠️ int is NOT supported! Always use sized integers.
# Creating addresses
addr = Address("0x03FB09251eC05ee9Ca36c98644070B89111D4b3F")
# Get sender
sender = gl.message.sender_address
# Conversions
hex_str = addr.as_hex # "0x03FB..."
bytes_val = addr.as_bytes # bytes
from dataclasses import dataclass
@allow_storage
@dataclass
class UserData:
name: str
balance: u256
active: bool
class MyContract(gl.Contract):
users: TreeMap[Address, UserData]
LLMs and web fetches produce different results across validators. GenLayer solves this with the Equivalence Principle.
strict_eq)All validators must produce identical results.
def get_data():
return gl.nondet.web.render(url, mode="text")
result = gl.eq_principle.strict_eq(get_data)
Best for: Factual data, boolean results, exact matches.
prompt_comparative)LLM compares leader's result against validators' results using criteria.
def get_analysis():
return gl.nondet.exec_prompt(prompt)
result = gl.eq_principle.prompt_comparative(
get_analysis,
"The sentiment classification must match"
)
Best for: LLM tasks where semantic equivalence matters.
prompt_non_comparative)Validators verify the leader's result meets criteria (don't re-execute).
result = gl.eq_principle.prompt_non_comparative(
lambda: input_data, # What to process
task="Summarize the key points",
criteria="Summary must be under 100 words and factually accurate"
)
Best for: Expensive operations, subjective tasks.
result = gl.vm.run_nondet(
leader=lambda: expensive_computation(),
validator=lambda leader_result: verify(leader_result)
)
| Function | Purpose |
|---|---|
gl.nondet.exec_prompt(prompt) | Execute LLM prompt |
gl.nondet.web.render(url, mode) | Fetch web page (mode="text" or "html") |
⚠️ Rules:
gl.storage.copy_to_memory()# Dynamic typing
other = gl.get_contract_at(Address("0x..."))
result = other.view().some_method()
# Static typing (better IDE support)
@gl.contract_interface
class TokenInterface:
class View:
def balance_of(self, owner: Address) -> u256: ...
class Write:
def transfer(self, to: Address, amount: u256) -> bool: ...
token = TokenInterface(Address("0x..."))
balance = token.view().balance_of(my_address)
other = gl.get_contract_at(addr)
other.emit(on='accepted').update_status("active")
other.emit(on='finalized').confirm_transaction()
child_addr = gl.deploy_contract(code=contract_code, salt=u256(1))
@gl.evm.contract_interface
class ERC20:
class View:
def balance_of(self, owner: Address) -> u256: ...
class Write:
def transfer(self, to: Address, amount: u256) -> bool: ...
token = ERC20(evm_address)
balance = token.view().balance_of(addr)
token.emit().transfer(recipient, u256(100)) # Messages only on finality
npm install -g genlayer
genlayer init # Download components
genlayer up # Start local network
# Direct deploy
genlayer deploy --contract my_contract.py
# With constructor args
genlayer deploy --contract my_contract.py --args "Hello" 42
# To testnet
genlayer network set testnet-asimov
genlayer deploy --contract my_contract.py
# Read (view methods)
genlayer call --address 0x... --function get_value
# Write
genlayer write --address 0x... --function set_value --args "new_value"
# Get schema
genlayer schema --address 0x...
# Check transaction
genlayer receipt --tx-hash 0x...
genlayer network # Show current
genlayer network list # Available networks
genlayer network set localnet # Local dev
genlayer network set studionet # Hosted dev
genlayer network set testnet-asimov # Testnet
prompt = f"""
Analyze this text and classify the sentiment.
Text: {text}
Respond using ONLY this JSON format:
{{"sentiment": "positive" | "negative" | "neutral", "confidence": float}}
Output ONLY valid JSON, no other text.
"""
from genlayer import UserError
@gl.public.write
def safe_operation(self, value: int) -> None:
if value <= 0:
raise UserError("Value must be positive")
# ... proceed
# Copy storage to memory for non-det blocks
data_copy = gl.storage.copy_to_memory(self.some_data)
def process():
return gl.nondet.exec_prompt(f"Process: {data_copy}")
result = gl.eq_principle.strict_eq(process)
See references/examples.md → LLM ERC20
See references/examples.md → Football Prediction Market
See references/examples.md → Log Indexer
genlayer up for local testingprint() works in contracts (debug only)references/sdk-api.md - Complete SDK API referencereferences/equivalence-principles.md - Consensus patterns in depthreferences/examples.md - Full annotated contract examples (incl. production oracle)references/deployment.md - CLI, networks, deployment workflowreferences/genvm-internals.md - VM architecture, storage, ABI details