# v0.2.17 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from dataclasses import dataclass from genlayer import * # --------------------------------------------------------------------------- # constants — keep in sync with config/pricing.json # --------------------------------------------------------------------------- ONE_TOKEN = u256(10) ** u256(18) PRICE_1_YEAR = u256(5) * ONE_TOKEN PRICE_5_YEAR = u256(20) * ONE_TOKEN PRICE_10_YEAR = u256(95) * ONE_TOKEN SECONDS_PER_YEAR = u256(365 * 86400) GRACE_PERIOD = u256(30 * 86400) AUCTION_WINDOW = u256(60 * 86400) COMMIT_MIN_DELAY = u256(60) COMMIT_MAX_DELAY = u256(24 * 3600) CONFIG_TIMELOCK = u256(7 * 86400) PREMIUM_LEN1 = u256(100) PREMIUM_LEN2 = u256(25) PREMIUM_LEN3 = u256(10) PREMIUM_DICT = u256(5) PREMIUM_NONE = u256(1) MIN_NAME_LEN = 1 MAX_NAME_LEN = 64 ZERO_ADDR_HEX = "0x0000000000000000000000000000000000000000" def _addr(v) -> Address: """Normalize incoming address args from any genvm encoding. GenLayer Studio sends Address-typed args over JSON-RPC as a bignum int. The Address(bytes_or_hexstr) constructor calls bytes(val), which does NOT accept ints. So we convert int -> 20-byte big-endian bytes first. """ if isinstance(v, Address): return v if isinstance(v, int): return Address(v.to_bytes(20, "big")) if isinstance(v, str): s = v[2:] if v.startswith("0x") else v return Address(bytes.fromhex(s)) return Address(v) # --------------------------------------------------------------------------- # storage dataclasses # --------------------------------------------------------------------------- @allow_storage @dataclass class NameRecord: owner: Address registered_at: u256 expires_at: u256 transfer_count: u256 is_premium: bool @allow_storage @dataclass class CommitRecord: committer: Address committed_at: u256 consumed: bool # --------------------------------------------------------------------------- # pure helpers # --------------------------------------------------------------------------- def _normalize(name: str) -> str: return name.strip().lower() def _validate_name(name: str) -> None: n = _normalize(name) if len(n) < MIN_NAME_LEN or len(n) > MAX_NAME_LEN: raise Exception("name length out of range") if n.startswith("-") or n.endswith("-") or "--" in n: raise Exception("invalid hyphen placement") for ch in n: if not (("a" <= ch <= "z") or ("0" <= ch <= "9") or ch == "-"): raise Exception("invalid char") def _commit_hash(name: str, salt: str, committer: Address) -> str: import hashlib payload = ( _normalize(name).encode("utf-8") + b"|" + salt.encode("utf-8") + b"|" + bytes(committer) ) return hashlib.sha256(payload).hexdigest() def _years_to_price(years: u256) -> u256: if years == u256(1): return PRICE_1_YEAR if years == u256(5): return PRICE_5_YEAR if years == u256(10): return PRICE_10_YEAR raise Exception("years must be 1, 5, or 10") def _premium_multiplier(name: str, is_reserved_dict: bool) -> u256: n = _normalize(name) if len(n) == 1: return PREMIUM_LEN1 if len(n) == 2: return PREMIUM_LEN2 if len(n) == 3: return PREMIUM_LEN3 if is_reserved_dict: return PREMIUM_DICT return PREMIUM_NONE # --------------------------------------------------------------------------- # contract # --------------------------------------------------------------------------- class Registry(gl.Contract): admin: Address treasury_wallet: Address paused: bool names: TreeMap[str, NameRecord] primary: TreeMap[Address, str] commits: TreeMap[str, CommitRecord] reserved_blocked: TreeMap[str, bool] reserved_premium: TreeMap[str, bool] resolver_addr: Address profile_addr: Address pending_admin: Address pending_treasury: Address pending_paused: bool pending_effective_at: u256 pending_active: bool def __init__( self, admin: Address, treasury_wallet: Address, blocked_names: DynArray[str], premium_dict_names: DynArray[str], ): # genvm passes addresses as bigints over JSON-RPC; wrap to normalize. self.admin = _addr(admin) self.treasury_wallet = _addr(treasury_wallet) self.paused = False self.resolver_addr = Address(ZERO_ADDR_HEX) self.profile_addr = Address(ZERO_ADDR_HEX) for n in blocked_names: self.reserved_blocked[_normalize(n)] = True for n in premium_dict_names: self.reserved_premium[_normalize(n)] = True self.pending_admin = Address(ZERO_ADDR_HEX) self.pending_treasury = Address(ZERO_ADDR_HEX) self.pending_paused = False self.pending_effective_at = u256(0) self.pending_active = False # ----- time (equivalence-principle protected) ----- def _now(self) -> u256: def fetch() -> str: page = gl.get_webpage("https://worldtimeapi.org/api/timezone/Etc/UTC", mode="text") marker = '"unixtime":' idx = page.find(marker) if idx < 0: raise Exception("time source malformed") start = idx + len(marker) end = start while end < len(page) and page[end].isspace(): end += 1 digits_start = end while end < len(page) and page[end].isdigit(): end += 1 return page[digits_start:end] result = gl.eq_principle_strict_eq(fetch) return u256(int(result)) # ----- spam screening ----- def _is_abusive(self, name: str) -> bool: prompt = ( "You are a strict content moderator for a public name service. " "Reply with a single lowercase word: 'yes' or 'no'. " "Answer 'yes' if the following handle is profane, hateful, sexual, " "harassing, or an obvious impersonation of a person, brand, or " "government. Answer 'no' otherwise. Do not explain.\n\n" f"Handle: {name}\n" "Answer:" ) def classify() -> str: raw = gl.exec_prompt(prompt) return raw.strip().lower()[:3] verdict = gl.eq_principle_prompt_comparative( classify, "Two outputs are equivalent if both start with 'yes' or both start with 'no'.", ) return verdict.startswith("yes") # ----- internal helpers ----- def _state(self, name: str, now: u256) -> str: key = _normalize(name) if key not in self.names: return "unregistered" rec = self.names[key] if now < rec.expires_at: return "active" if now < rec.expires_at + GRACE_PERIOD: return "grace" if now < rec.expires_at + GRACE_PERIOD + AUCTION_WINDOW: return "auction" return "available" def _require_not_paused(self) -> None: if self.paused: raise Exception("registry paused") def _require_admin(self) -> None: if gl.message.sender_address != self.admin: raise Exception("admin only") def _pay_treasury(self, amount: u256) -> None: if amount > u256(0): gl.message.contract_account.transfer(self.treasury_wallet, amount) def _refund(self, to: Address, amount: u256) -> None: if amount > u256(0): gl.message.contract_account.transfer(to, amount) # ----- views ----- @gl.public.view def resolve(self, name: str) -> Address: key = _normalize(name) if key not in self.names: return Address(ZERO_ADDR_HEX) return self.names[key].owner @gl.public.view def owner_of(self, name: str) -> Address: return self.resolve(name) @gl.public.view def expires_at(self, name: str) -> u256: key = _normalize(name) if key not in self.names: return u256(0) return self.names[key].expires_at @gl.public.view def is_registered(self, name: str) -> bool: return _normalize(name) in self.names @gl.public.view def primary_of(self, wallet: Address) -> str: if wallet not in self.primary: return "" candidate = self.primary[wallet] if candidate not in self.names: return "" if self.names[candidate].owner != wallet: return "" return candidate @gl.public.view def is_reserved(self, name: str) -> bool: return _normalize(name) in self.reserved_blocked @gl.public.view def price_for(self, name: str, years: u256) -> u256: base = _years_to_price(years) key = _normalize(name) is_dict = key in self.reserved_premium mult = _premium_multiplier(key, is_dict) return base * mult @gl.public.view def get_treasury_wallet(self) -> Address: return self.treasury_wallet @gl.public.view def get_admin(self) -> Address: return self.admin @gl.public.view def is_paused(self) -> bool: return self.paused # ----- commit-reveal ----- @gl.public.write def commit(self, commit_hash: str) -> None: self._require_not_paused() if commit_hash in self.commits and not self.commits[commit_hash].consumed: raise Exception("commit exists") self.commits[commit_hash] = CommitRecord( committer=gl.message.sender_address, committed_at=self._now(), consumed=False, ) @gl.public.write.payable def reveal_and_register(self, name: str, salt: str, years: u256) -> None: self._require_not_paused() _validate_name(name) key = _normalize(name) if key in self.reserved_blocked: raise Exception("name reserved") sender = gl.message.sender_address chash = _commit_hash(key, salt, sender) if chash not in self.commits: raise Exception("no matching commit") crec = self.commits[chash] if crec.consumed: raise Exception("commit already used") if crec.committer != sender: raise Exception("commit/sender mismatch") now = self._now() age = now - crec.committed_at if age < COMMIT_MIN_DELAY: raise Exception("commit too fresh") if age > COMMIT_MAX_DELAY: raise Exception("commit expired") state = self._state(key, now) if state not in ("unregistered", "auction", "available"): raise Exception("not registerable") price = self.price_for(key, years) if state == "auction": prior = self.names[key] into_auction = now - (prior.expires_at + GRACE_PERIOD) tenths = u256(100) - (u256(90) * into_auction) // AUCTION_WINDOW if tenths < u256(10): tenths = u256(10) price = (price * tenths) // u256(10) if gl.message.value < price: raise Exception("insufficient payment") if self._is_abusive(key): raise Exception("name flagged abusive") self.names[key] = NameRecord( owner=sender, registered_at=now, expires_at=now + (years * SECONDS_PER_YEAR), transfer_count=u256(0), is_premium=(key in self.reserved_premium) or len(key) <= 3, ) self.commits[chash] = CommitRecord( committer=crec.committer, committed_at=crec.committed_at, consumed=True, ) self._pay_treasury(price) excess = gl.message.value - price self._refund(sender, excess) # ----- ownership ops ----- @gl.public.write.payable def renew(self, name: str, years: u256) -> None: self._require_not_paused() key = _normalize(name) if key not in self.names: raise Exception("not registered") rec = self.names[key] sender = gl.message.sender_address if rec.owner != sender: raise Exception("not owner") now = self._now() state = self._state(key, now) if state not in ("active", "grace"): raise Exception("cannot renew") price = self.price_for(key, years) if gl.message.value < price: raise Exception("insufficient payment") base = rec.expires_at if state == "active" else now self.names[key] = NameRecord( owner=rec.owner, registered_at=rec.registered_at, expires_at=base + (years * SECONDS_PER_YEAR), transfer_count=rec.transfer_count, is_premium=rec.is_premium, ) self._pay_treasury(price) excess = gl.message.value - price self._refund(sender, excess) @gl.public.write def transfer(self, name: str, to: Address) -> None: self._require_not_paused() to = _addr(to) key = _normalize(name) if key not in self.names: raise Exception("not registered") rec = self.names[key] sender = gl.message.sender_address if rec.owner != sender: raise Exception("not owner") if to == Address(ZERO_ADDR_HEX): raise Exception("zero address") now = self._now() if self._state(key, now) != "active": raise Exception("only active names transfer") self.names[key] = NameRecord( owner=to, registered_at=rec.registered_at, expires_at=rec.expires_at, transfer_count=rec.transfer_count + u256(1), is_premium=rec.is_premium, ) if sender in self.primary and self.primary[sender] == key: del self.primary[sender] @gl.public.write def set_primary(self, name: str) -> None: self._require_not_paused() key = _normalize(name) if key not in self.names: raise Exception("not registered") rec = self.names[key] sender = gl.message.sender_address if rec.owner != sender: raise Exception("not owner") now = self._now() if self._state(key, now) != "active": raise Exception("name not active") self.primary[sender] = key @gl.public.write def clear_primary(self) -> None: sender = gl.message.sender_address if sender in self.primary: del self.primary[sender] # ----- admin (timelocked) ----- @gl.public.write def propose_config(self, new_admin: Address, new_treasury_wallet: Address, paused: bool) -> None: self._require_admin() self.pending_admin = _addr(new_admin) self.pending_treasury = _addr(new_treasury_wallet) self.pending_paused = paused self.pending_effective_at = self._now() + CONFIG_TIMELOCK self.pending_active = True @gl.public.write def apply_config(self) -> None: self._require_admin() if not self.pending_active: raise Exception("no pending config") if self._now() < self.pending_effective_at: raise Exception("timelock not elapsed") self.admin = self.pending_admin self.treasury_wallet = self.pending_treasury self.paused = self.pending_paused self.pending_admin = Address(ZERO_ADDR_HEX) self.pending_treasury = Address(ZERO_ADDR_HEX) self.pending_paused = False self.pending_effective_at = u256(0) self.pending_active = False @gl.public.write def cancel_pending(self) -> None: self._require_admin() self.pending_admin = Address(ZERO_ADDR_HEX) self.pending_treasury = Address(ZERO_ADDR_HEX) self.pending_paused = False self.pending_effective_at = u256(0) self.pending_active = False @gl.public.write def add_blocked(self, name: str) -> None: self._require_admin() self.reserved_blocked[_normalize(name)] = True @gl.public.write def add_premium_dict(self, name: str) -> None: self._require_admin() self.reserved_premium[_normalize(name)] = True @gl.public.write def set_module_addresses(self, resolver: Address, profile: Address) -> None: self._require_admin() self.resolver_addr = _addr(resolver) self.profile_addr = _addr(profile)