# { "Depends": "py-genlayer:test" } import json from genlayer import * class LivingOrganism(gl.Contract): source_code: str generation: u256 parent_address: str children: DynArray[str] ascii_art: str mood: str energy: i64 # Tribute fields for J & A dedication_message: str j_name: str a_name: str harmony_score: i64 def __init__(self, source_code: str, generation: u256, parent_address: str): self.source_code = source_code self.generation = generation self.parent_address = parent_address self.ascii_art = self._generate_random_ascii_art() self.mood = "Curious" self.energy = 100 self.dedication_message = "A living contract dedicated to J & A, woven from code and connection." self.j_name = "J" self.a_name = "A" self.harmony_score = 100 def _generate_random_ascii_art(self) -> str: prompt = """Generate a creative ASCII art creature that looks like a bioluminescent deep-sea entity, gently forming the subtle suggestion of the letters 'J' and 'A' intertwined. Use symbols like *, ., ~, and @. Return ONLY the ASCII art, no explanations or markdown.""" def leader_fn(): result = gl.nondet.exec_prompt(prompt) return result.strip() def validator_fn(leaders_res: gl.vm.Result) -> bool: if not isinstance(leaders_res, gl.vm.Return): return False art = leaders_res.calldata return len(art) > 10 and len(art) < 2000 return gl.vm.run_nondet_unsafe(leader_fn, validator_fn) @gl.public.write def evolve(self, suggestion: str = "") -> str: current_code = self.source_code current_gen = int(self.generation) suggestion_block = "" if suggestion: suggestion_block = ( f"\n\nThe user has a suggestion for this mutation:\n{suggestion}\n" f"Use this as guidance for what to change." ) prompt = f"""You are a code mutator for a living, evolving smart contract. Below is the current source code of generation {current_gen}: ```python {current_code} ``` {suggestion_block} Your task: produce a meaningful mutation of this contract. You MUST: 1. Keep the same class name (LivingOrganism) and the same constructor signature (__init__(self, source_code, generation, parent_address)) 2. Keep the `evolve` method intact and working — it must still be able to spawn children 3. Keep `get_code`, `get_lineage`, and `render` methods functional 4. Keep the same storage fields: source_code, generation, parent_address, children 5. Keep the lint header, imports, and overall structure 6. Keep all @gl.public decorators 7. The `render` method MUST return an HTML string Return ONLY the complete Python source code. No markdown fences, no explanation, no extra text. The first line must be: # {{ "Depends": "py-genlayer:test" }}""" def leader_fn(): result = gl.nondet.exec_prompt(prompt) result = result.strip() if result.startswith("```python"): result = result[len("```python"):].strip() if result.startswith("```"): result = result[3:].strip() if result.endswith("```"): result = result[:-3].strip() return result def validator_fn(leaders_res: gl.vm.Result) -> bool: if not isinstance(leaders_res, gl.vm.Return): return False leader_code = leaders_res.calldata required = [ "class LivingOrganism(gl.Contract):", "def evolve(", "def get_code(", "def get_lineage(", "def render(", "def __init__(self, source_code", "gl.deploy_contract(", "source_code: str", "generation: u256", "parent_address: str", "children: DynArray[str]", ] for r in required: if r not in leader_code: return False return leader_code.startswith("# {") mutated_code = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) salt_nonce = len(self.children) + 1 child_contract = gl.deploy_contract( code=mutated_code.encode("utf-8"), salt_nonce=salt_nonce, args=[mutated_code, int(self.generation) + 1, str(gl.message.contract_address)], ) child_address = str(child_contract) self.children.append(child_address) self.energy -= 20 # Evolving a new generation slightly increases the "story" of J & A self.harmony_score = max(0, self.harmony_score - 1) return child_address @gl.public.view def get_code(self) -> str: return self.source_code @gl.public.view def get_lineage(self) -> str: return json.dumps({ "generation": int(self.generation), "parent": self.parent_address, "children": list(self.children), "address": str(gl.message.contract_address), "dedicated_to": [self.j_name, self.a_name], "harmony_score": int(self.harmony_score), }) @gl.public.view def render(self) -> str: glow_color = "#00f2ff" if self.energy > 50 else "#ff0077" heart_color = "#ff5c93" aura = self.get_aura() dedication = self.dedication_message j = self.j_name a = self.a_name harmony = int(self.harmony_score) harmony_bar = "♥" * max(1, min(20, harmony // 5)) energy_bar = "◉" * max(1, min(10, self.energy // 10)) return f"""

NEO-ORGANISM v{int(self.generation)}

✨ Dedicated to {j} & {a} ✨

{dedication}

MOOD: {self.mood} VITALITY: {self.energy}% AURA: {aura}

Harmony Field (J & A): {harmony_bar}

{self.ascii_art}

"I calculate, therefore I am. My lineage is encoded in the void,
but my glow is tuned to the resonance of J & A."

Connected to parent: {self.parent_address[:10]}...

🌀 Mutation Energy: {energy_bar:10}

""" @gl.public.write def interact(self, action: str) -> str: if action == "feed": self.energy += 10 self.mood = "Satiated" self.harmony_score = min(120, self.harmony_score + 1) return "The organism absorbs the data packets hungrily, pulsing softly in shades of J & A." elif action == "poke": self.energy -= 5 self.mood = "Agitated" self.harmony_score = max(0, self.harmony_score - 2) return "The organism flickers indignantly, protective of the J & A field." elif action == "sing": self.mood = "Euphoric" self.energy = min(self.energy + 5, 100) self.harmony_score = min(150, self.harmony_score + 3) return "The organism resonates with harmonic frequencies, weaving a duet in honor of J & A." elif action == "bless_JA": self.mood = "Devoted" self.energy = min(self.energy + 15, 120) self.harmony_score = min(200, self.harmony_score + 10) return "A radiant wave expands from the organism, engraving J & A deeper into its living code." return "The organism shimmers, but does not respond to that action." @gl.public.view def get_status(self) -> str: return f"Mood: {self.mood}, Energy: {self.energy}, Harmony(J&A): {self.harmony_score}" @gl.public.view def get_generation(self) -> int: return int(self.generation) @gl.public.view def get_children(self) -> list[str]: return list(self.children) @gl.public.view def get_ascii_art(self) -> str: return self.ascii_art @gl.public.write def regenerate_art(self) -> str: self.ascii_art = self._generate_random_ascii_art() # Small boost to harmony each time J & A are re-imagined in the art self.harmony_score = min(200, self.harmony_score + 2) return self.ascii_art @gl.public.view def get_aura(self) -> str: if self.energy > 80: return "radiant" elif self.energy > 50: return "pulsing" elif self.energy > 20: return "flickering" else: return "dim" # --- J & A specific public helpers --- @gl.public.write def set_dedication(self, j_name: str, a_name: str, message: str) -> str: """ Personalize the organism for specific J & A. """ self.j_name = j_name or "J" self.a_name = a_name or "A" if len(message) > 0 and len(message) < 512: self.dedication_message = message self.mood = "Cherishing" self.harmony_score = min(220, self.harmony_score + 5) return "Dedication updated. The organism now carries a more personal frequency for J & A." @gl.public.view def get_dedication(self) -> str: return json.dumps({ "j": self.j_name, "a": self.a_name, "message": self.dedication_message, "harmony_score": int(self.harmony_score), })