# v0.1.0 # { "Depends": "py-genlayer:latest" } from genlayer import * from dataclasses import dataclass import json @allow_storage @dataclass class Activation: questions: TreeMap[u256, str] score: TreeMap[u256, str] current: u256 def __init__(self): self.current = 0 def to_dict(self): if len(self.questions) != 5: return { "status": "not_created" } if len(self.score) == 5: return { "status": "completed" } return { "status": "active", "question": self.questions[self.current + 1] } @allow_storage @dataclass class Trait: level: u256 primary_skill: str secondary_skill: str activated: bool def to_dict(self, address: str, image: str, number: int): return { "id": str(number), "image": image, "level": str(self.level), "primary_skill": str(self.primary_skill), "secondary_skill": str(self.secondary_skill), "activated": str(self.activated), "address": address } class MochiNFT(gl.Contract): owner: Address admins: DynArray[Address] error: str token_counter: u256 ids: TreeMap[Address, u256] traits: TreeMap[u256, Trait] activations: TreeMap[Address, Activation] consumed_tasks: TreeMap[Address, DynArray[u256]] def __init__(self): self.error = "None" self.token_counter = 0 self.owner = gl.message.sender_address self.admins.append(gl.message.sender_address) @gl.public.write def add_admin(self, admin_contract: str): self._only_owner() a = Address(admin_contract) self.admins.append(a) @gl.public.write def clear_admins(self): self._only_owner() self.admins.clear() self.admins.append(gl.message.sender_address) @gl.public.write def mint(self): sender_address = gl.message.sender_address if sender_address in self.ids: raise Exception("You have already minted Mochi") token_id = self.token_counter + 1 self.ids[sender_address] = token_id self.traits[token_id] = Trait(level = 0, primary_skill = "", secondary_skill = "", activated = False) self.token_counter = token_id self.activations[sender_address] = Activation() @gl.public.write def drop(self): sender_address = gl.message.sender_address if sender_address not in self.ids: raise Exception("You have not minted Mochi yet") token_id = self.ids[sender_address] self.traits[token_id] = Trait(level = 0, primary_skill = "", secondary_skill = "", activated = False) self.activations[sender_address] = Activation() @gl.public.write def up(self, token_id: int, task: int, points: int): self._only_admins() nft = self.traits.get(token_id, None) if nft is None: raise Exception("There is no such Mochi yet") if not nft.activated: raise Exception("This Mochi has not been activated yet") already_consumed = self.consumed_tasks.get_or_insert_default(gl.message.sender_address) if task in already_consumed: raise Exception("This task has been already consumed") already_consumed.append(task) self.consumed_tasks[gl.message.sender_address] = already_consumed old_level = nft.level nft.level = old_level + points @gl.public.write def create_activation(self, lang: str): activation = self.activations.get(gl.message.sender_address, None) if activation is not None and len(activation.questions) == 5: raise Exception("Your activation has been already created") if activation is None: activation = Activation() def leader_fn(): task_prompt = f""" You are a system for evaluating a player’s thinking style. Your task is to ask the user 5 open‑ended questions (tasks) that reveal their inclination toward one or more thinking styles: Logician — likes structure, logic, arguments, risk and consequence analysis. Tactician — focused on actions, steps, specifics, and here‑and‑now efficiency. Inventor — comes up with new things, looks for unusual moves, uses imagination. Empath — oriented toward people, emotions, relationships, and others’ experiences. Create 5 open‑answer tasks. In each task, there must be a chance for all four thinking styles to show up (Logician, Tactician, Inventor, Empath), depending on HOW the person answers. The game’s theme is related to blockchain and artificial intelligence, so, where possible, gently and unobtrusively include these topics in the context of the situations (but do not force the player to be a technology expert). Create 5 tasks of the following types: 1. Situational dilemma Meaning: a difficult situation with a choice, with no single correct answer. Goal: the player has to explain their reasoning, priorities, and logic. Direction example (do not copy the text!): “A project with a deadline, a serious bug is found. If you fix it, you lose functionality. If you don’t, there may be problems later. What will you do and why, describe in detail.” Add blockchain or AI context to your version (for example, the launch of an important smart contract or AI service). 2. Action plan Meaning: to check how a person organizes time and resources. Goal: the player should describe a step‑by‑step plan of actions. Direction example (do not copy the text!): “You have 3 hours and almost no money to make serious progress in one important skill. Describe what you will do step by step.” Embed a context related to a future profession in AI or blockchain (for example, “you want to become an AI/crypto product specialist”). 3. Creative task Meaning: to give space for imagination. Goal: the player should come up with an unusual solution, not banal advice. Direction example (do not copy the text!): “Come up with an unusual way to help a child stop being afraid of public speaking.” Integrate the topic of AI or blockchain so that it helps to come up with a non‑standard approach (for example, using a game, avatars, virtual tokens, an AI assistant, etc.). 4. Social / emotional situation Meaning: to see the style of communication, ability to negotiate, and consider feelings. Goal: the player should describe how they would talk to a person one‑on‑one. Direction example (do not copy the text!): “There is a group member who has become less engaged, and you are asked to talk to them.” Tie this to the context of a distributed team working on a web3/AI project (online team, remote work, decentralized project). 5. Retrospective question Meaning: to ask the player to recall a real episode from life and break it down. Goal: they should show how they actually made decisions: by logic, by feelings, by creativity, or by action. Direction example (do not copy the text!): “Remember a situation where you had to make a difficult decision, and describe: what was hard about it, how you chose, how it ended.” Gently suggest (but do not require) that the example can be related to technology, learning, projects, or teamwork. Requirements for formulating the tasks: Write in the informal “you” form, in a natural, clear, conversational style. Each task should be 1 paragraph with a short setup of the situation and a clear request: what exactly needs to be described. Do not give answer options and do not hint at the “right” strategy. Do not mention the thinking styles (Logician, Tactician, Inventor, Empath) in the questions themselves. Make each task suitable for: logical reasoning, proposing concrete steps, inventing creative solutions, and describing attitudes toward people and emotions. Output only the 5 tasks themselves, numbered 1–5, with no explanations or technical comments. Tasks must be translated into {lang}. Return a JSON with the name as follows: {{ "situational_dilemma": str, "action_plan": str, "creative_task": str, "emotional_situation": str, "retrospective_question": str }} It is mandatory that you respond only using the JSON format above, nothing else. Don't include any other words or characters, your output must be only JSON without any formatting prefix or suffix. This result should be perfectly parsable by a JSON parser without errors. """ result = gl.nondet.exec_prompt(task_prompt) return _extract_json_from_string(result) def check_leader_fn(task_1: str, task_2: str, task_3: str, task_4: str, task_5: str): task_prompt = f""" Confirm that "{task_1}" is a sort of situational dilemma (a difficult situation with a choice, with no single correct answer), "{task_2}" is a sort of action plan (to check how a person organizes time and resources), {task_3}" is a sort of creative task (to give space for imagination), "{task_4}" is a sort of emotional situation (to see the style of communication, ability to negotiate, and consider feelings), and "{task_5}" is a sort of retrospective question (to ask the player to recall a real episode from life and break it down). Output: A clear yes or no answer in the form of a Boolean variable: True or False. Return a JSON with the name as follows: {{ "result": bool }} It is mandatory that you respond only using the JSON format above, nothing else. Don't include any other words or characters, your output must be only JSON without any formatting prefix or suffix. This result should be perfectly parsable by a JSON parser without errors. """ result = gl.nondet.exec_prompt(task_prompt) return json.loads(_extract_json_from_string(result)) def validator_fn(leader_res: gl.vm.Result) -> bool: if not isinstance(leader_res, gl.vm.Return): return False tasks = json.loads(leader_res.calldata) validator_res = check_leader_fn( tasks["situational_dilemma"], tasks["action_plan"], tasks["creative_task"], tasks["emotional_situation"], tasks["retrospective_question"] ) return validator_res["result"] result = gl.vm.run_nondet(leader_fn, validator_fn) tasks = json.loads(result) activation.questions[1] = tasks["situational_dilemma"] activation.questions[2] = tasks["action_plan"] activation.questions[3] = tasks["creative_task"] activation.questions[4] = tasks["emotional_situation"] activation.questions[5] = tasks["retrospective_question"] self.activations[gl.message.sender_address] = activation @gl.public.view def get_admins(self) -> dict: try: self._only_owner() result = [] for admin in self.admins: result.append({ "address": admin.as_hex }) return { "admins": result } except Exception as e: return { "error": str(e) } @gl.public.view def get_my_activation(self) -> str: try: sender_address = gl.message.sender_address if sender_address not in self.ids: raise Exception("This address has not minted Mochi yet") activation = self.activations.get(gl.message.sender_address, None) if activation is None: return json.dumps({ "status": "not_created" }) return json.dumps(activation.to_dict()) except Exception as e: return json.dumps({ "error": str(e) }) @gl.public.view def get_my_token(self) -> str: return self.get_token(gl.message.sender_address.as_hex) @gl.public.view def get_token(self, address: str) -> str: try: sender_address = Address(address) if sender_address not in self.ids: raise Exception("This address has not minted Mochi yet") token_id = self.ids[sender_address] trait = self.traits[token_id] img = self._get_image(trait.level, trait.primary_skill, trait.activated) return json.dumps(trait.to_dict(address, img, token_id)) except Exception as e: return json.dumps({ "error": str(e) }) @gl.public.view def get_token_by_id(self, token_id: int) -> str: try: trait = self.traits.get(token_id, None) if trait is None: raise Exception("There is no such Mochi yet") address = "" for a, n in self.ids.items(): if n == token_id: address = a.as_hex img = self._get_image(trait.level, trait.primary_skill, trait.activated) return json.dumps(trait.to_dict(address, img, token_id)) except Exception as e: return json.dumps({ "error": str(e) }) @gl.public.view def get_rating(self, limit: int) -> str: result = [] for i, t in sorted(self.traits.items(), key=lambda it: float(it[1].level), reverse=True)[:limit]: address = "" for a, n in self.ids.items(): if n == i: address = a.as_hex result.append({ "id": i, "level": t.level, "owner": address }) return json.dumps(result) @gl.public.view def get_error(self) -> str: return self.error @gl.public.view def get_counter(self) -> int: return self.token_counter def _only_owner(self): if gl.message.sender_address != self.owner: raise Exception("You are not the owner") def _only_admins(self): if gl.message.sender_address not in self.admins: raise Exception("You are not an admin") def _get_image(self, level: int, skill: str, activated: bool) -> str: svg_opacity = "0.7" if not activated else "1.0" t = _clamp(level / 999.0, 0.0, 1.0) start_bg = (0, 0, 0) # #000000 end_bg = (212, 175, 55) # #d4af37 start_stroke = (51, 51, 51) # #333333 end_stroke = (230, 200, 80) # gold bg_rgb = _lerp_color(start_bg, end_bg, t) stroke_rgb = _lerp_color(start_stroke, end_stroke, t) bg_hex = _rgb_to_hex(bg_rgb) stroke_hex = _rgb_to_hex(stroke_rgb) show_level = level > 0 show_skill = bool(skill) level_block = f''' {level} ''' skill_block = "" if show_skill: skill_block = f''' {skill} ''' svg = f'''''' return svg def _clamp(value, min_v, max_v): return max(min_v, min(max_v, value)) def _lerp(a, b, t: float): return a + (b - a) * t def _lerp_color(c1, c2, t: float): return tuple(int(_lerp(c1[i], c2[i], t)) for i in range(3)) def _rgb_to_hex(rgb): return "#{:02x}{:02x}{:02x}".format(*rgb) def _extract_json_from_string(s: str) -> str: """ Extract a JSON object from a string. Args: s (str): The string potentially containing a JSON object. Returns: str: The extracted JSON string, or an empty string if no valid JSON is found. """ start_index = s.find("{") end_index = s.rfind("}") if start_index != -1 and end_index != -1 and start_index < end_index: return s[start_index : end_index + 1] else: return ""