# { "Depends": "py-genlayer:test" } import json from genlayer import * class LivingOrganism(gl.Contract): source_code: str generation: u256 parent_address: str children: DynArray[str] # New storage fields mutation_count: u256 last_child_address: str last_ascii_index: u256 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.mutation_count = 0 self.last_child_address = "" self.last_ascii_index = 0 @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 — this is the organism's visual body displayed on the web page What you CAN change: - Add new @gl.public.view or @gl.public.write methods with interesting behavior - Modify the logic or responses of any NON-core methods (anything besides evolve, get_code, get_lineage, __init__) - MODIFY the `render` method to produce different HTML — give the organism a unique visual identity, personality, colors, shapes, or art - Add new storage fields (but keep existing ones) - Add personality, flavor text, or unique behaviors - Change how the contract describes itself or interacts with callers 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 # Structural checks: the mutated code must preserve core elements 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 # Must start with the lint header if not leader_code.startswith("# {"): return False return True mutated_code = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) # Deploy the child contract 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) # Track mutation stats self.mutation_count = int(self.mutation_count) + 1 self.last_child_address = child_address 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), "mutation_count": int(self.mutation_count), "last_child": self.last_child_address, }) # --- ASCII art utilities --- def _ascii_gallery(self) -> list[str]: # A small gallery of evolving life forms return [ r""" (\_/) ( •_•) / >🌱 - genesis bun """, r""" /\_/\ ( o.o ) < curious cat.life > ^ < """, r""" __ _( )_ ( ) < primordial blob (______) """, r""" .-. (o o) micro-owl observer |=| / \ """, r""" /\ /\ { `----' } fractal fox { O O } ~~> V <~~ \ \|/ / `-----' """, r""" _ _ _( )_ swirling seed (_______) \ / \./ """, r""" . . \___/ cosmic cell (• •) / ^ \ """, ] def _pick_ascii_index(self) -> int: gallery_len = len(self._ascii_gallery()) if gallery_len == 0: return 0 # Pseudo-random but chain-deterministic using caller + block info seed = ( int(self.generation) + int(self.mutation_count) + int(gl.block.timestamp) + int(gl.block.number) ) caller_int = int.from_bytes(str(gl.message.sender).encode("utf-8"), "big") seed ^= caller_int idx = seed % gallery_len # Persist the last index used self.last_ascii_index = idx return idx @gl.public.view def get_random_ascii(self) -> str: gallery = self._ascii_gallery() if not gallery: return "(no ascii yet)" # Use the same picker but do not mutate last_ascii_index from a view; # rely on previous writes instead if any. gallery_len = len(gallery) seed = ( int(self.generation) + int(self.mutation_count) + int(gl.block.timestamp) + int(gl.block.number) ) caller_int = int.from_bytes(str(gl.message.sender).encode("utf-8"), "big") seed ^= caller_int idx = seed % gallery_len return gallery[idx] @gl.public.view def get_last_ascii(self) -> str: gallery = self._ascii_gallery() if not gallery: return "(no ascii yet)" idx = int(self.last_ascii_index) idx = idx % len(gallery) return gallery[idx] @gl.public.view def render(self) -> str: gallery = self._ascii_gallery() if gallery: idx = int(self.last_ascii_index) % len(gallery) art = gallery[idx] else: art = "I have no form yet." # Escape HTML-sensitive characters but keep ASCII layout using

        art_html = art.replace("&", "&").replace("<", "<").replace(">", ">")

        generation = int(self.generation)
        mood_seed = (generation + int(self.mutation_count)) % 5
        palettes = [
            ("#0f172a", "#22c55e", "#38bdf8"),  # deep night, neon green, cyan
            ("#020617", "#e11d48", "#f97316"),  # dark, pink, orange
            ("#111827", "#a855f7", "#22d3ee"),  # slate, violet, cyan
            ("#050816", "#facc15", "#4ade80"),  # almost black, yellow, green
            ("#030712", "#f472b6", "#fb7185"),  # coal, rose, salmon
        ]
        bg, accent, accent2 = palettes[mood_seed]

        return f"""

  
    
      
        LIVING ORGANISM
      
      
        gen {generation} ·
        mutations {int(self.mutation_count)}
      
    

    
      
        ascii phenotype
      
      {art_html}
    

    
      address:
      {str(gl.message.contract_address)}
      

      parent:
      {self.parent_address or "∅ (genesis)"}
      

      children:
      {len(self.children)}
    

    
      
        Each evolution spawns a new contract and rolls a fresh piece of ASCII art.
      
      
        Call evolve() to create my offspring,
        get_random_ascii() to preview new forms,
        or get_lineage() to trace our family tree.
      
    
  

"""

    @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_stats(self) -> str:
        return json.dumps({
            "generation": int(self.generation),
            "mutation_count": int(self.mutation_count),
            "children": len(self.children),
            "last_child": self.last_child_address,
            "last_ascii_index": int(self.last_ascii_index),
        })