Author : Fifoooo(11008), PG(4895) Quorum Requirement : 20% (9M) Vote Duration : 14 Days Discord thread: https://discord.com/channels/732491344970383370/1294627583299686421

Intro

Last 6 / 9 months, I participated to the Battler tournaments, Rarity farming, and played Dropt and SFA a bit.... I think it's too complicated when it came to managing my gotchis and which wearable goes where. What I mean is that it could be easier with some better tools / features. Each game requires some optimization in terms of the wearable you use in order to perform properly.

With all that in mind I think that at least 2 features are actually missing in the ecosystem.

• A "save and restore" system for gotchis. I can save some wearable configurations for a gotchi I own, put a name on each config, and restore my gotchi to that config later on
• A unified UI where I can see the perks and attributes of my gotchi on each game (Battler, SFA, Dropt, Strategotchi, Gotchi Guardians and more to come).

At that point I contacted CoderDan, for 2 reasons:

• First I did not want to start working on this if PC was already working on something similar for the official dapp (they were not indeed).
• The "save and restore" would be a nice addition to the aavegotchi diamond contract. We are a web3 gaming community and I did not see why I would store that data off-chain.

Here is a quick recap of what came out of those discussions:

• If this proposal is adopted, PC has agreed to let me implement those features directly on the official dapp, based on the mockup and ideas I provided.
• The features will be tested on Polter and released on Geist directly.
• Regarding the per-game UI I will also deliver an open-source data schema that will store all in-games specific traits for gotchis and their wearables, for each available game at the moment. The repo will be open sourced. The goal is to streamline the update process (more on that below).
• Some additions will need to be made on the diamond contract. On that part too PC has agreed that we can submit some PR that they will review. A subgraph that gives easier access to all those datas will also be delivered.

You will find below more details about each features, then the actual costing of everything.

Feature details

Per-game gotchi details

UI & integration.

This feature would be added directly into the gotchi detail dialog. You can see in the figma linked below how it could look like (i'm not a UI designer, so you get an idea but final UI will be more polished than that ofc).

Full UI preview here:
https://www.figma.com/design/ArbrjPnDlCgIzcS2in7Rn3/aavegotchi_dapp_per_game_details?node-id=34-95&t=j4Q7aA9EKFHI58G2-1

I will be in charge of the implementation with direct access to the source code provided by PixelCraft. This feature should vastly improve "quality of life" of the ecosystem users, as you do not need to switch between multiple sites to see the impact of some wearable on your gotchi, for each games. Plus it puts the list of all games in one of the most important page of the dapp. So it's a way to tell newcomers: "look all the games you can play with your gotchis". That's why a link to each game will also be added to that page (see in the figma for more details).

Schema design.

There have been some discussions about it before in the Discord but no action taken so far. Basically it's a data structure that can store all the specs and logical rules for each games separately. There are many advantages having all that information inside a schema instead of raw-coding the whole logic.

• The schema can be shared and reused in other dapps.
• A game maker can update the schema by himself when he makes a balance change or release a major version. This insures the schema remains up to date with the game more easily. That way every other dapp that relies on the schema also gets the update.
• Even if it's not as readable as a wiki that details mecanics, it remains publicly available so games are not black box at all in that regards.

I plan to use jsonlogic to implement per game schema. This engine allows to describe some logics inside static json files and then share that same logic. Plus this engine is available multiple platforms (Js, Python, C#, java, ruby) which helps when it comes to reusability.

All the datas in the schema, for all the games, would be stored inside a public github repository that I would set up, including the creation of the initial schema for every game that actually needs it. That way the game makers do not start from scratch when it comes to it, ground work will be done, they will just need to push updates.

This repository and a first version of the schema for each game is part of what I would like to deliver through this proposal

"save and restore" system for gotchis

Description

This feature will allow users to store on-chain wearable configs for each game they use to play, then to switch easily from one config to another. On chain storage and a well-thought UI will allow users to make those switches easily. Because storage is on-chain and a subgraph will be also part of the deliverable, other dapps and even games could decide to use those features. Meaning in the future, you could launch an aavegotchi game and switch your gotchi config directly in-game. Other way to use this config system could emerge, for example a gotchi config could be shared through a unique url on discord, X, lens, so people can get some inspiration from it. As the community suggested in the DAO thread, each gotchi will be allowed to use 3 free slots to save configs, additional slots will cost a 1GHST fee each, this fee will go to the DAO fund.

UI & integration

Full UI preview here: https://www.figma.com/design/KPsjwWdAI8jJdGQkMbCYsE/aavegotchi_dapp_dressing?node-id=23-301&t=qsoD5EP4kxRTvAOw-1

The feature will be accessible from the gotchi equip page of the official dapp. On click it will open a modal where you can:

• Save the current config if it's not already saved.
• See the configs you have already saved for that gotchi.
• Restore a previous config

When you ask the dapp to restore a previous config, the dapp will take care of all checks.

• If at least one wearable is not available anymore on your inventory it will warn you which one(s) and cancel
• If at least one wearable is already equipped on another gotchi you own it will warn you that this werable is going to be unequip from the other gotchi beforehand. The dapp will take care of all the Tx automatically.

Smart contract work.

Dan suggested we add a new facet to the aavegotchi diamond, called WearableConfig. We will put all the solidity stuff in there. In addition to that, a "batchEquip" function will be added to the "ItemsFacet". The goal is that if the dapp needs to undress some gotchis first, then we can do all that in one Tx, which is way better regarding user experience.

Subgraph.

In order to provide an easier and wider access to the configs, a subgraph will be developped in order to expose those new datas.

Deliverables.

If I recap all the part that should be delivered :

• For the "Per-game gotchi details", we have a UI added to the official dapp and an open source schema in a separated demo with a complete first implementation for each game.
• For the "save and restore" system for gotchis, we have also a UI added to the official dapp, additions to the aavegotchi diamond smart contract for on-chain storage and a subgraph for easier access to the datas.

Budget

I made an estimation of both features in terms of dev time. I will handle all the tasks, except for those 2:

• @CoderDan offered me that a UI designer from PC helps me by preparing a better UI through Figma.
• @PG will handle all the solidity aspects. I have worked with him on several occasions and he's way better than me when it comes to Solidity.

With all that in mind, the overall budget is 19340$.

• 10700$ for "backup / restore" (4900$ for UI, 3600$ for Solidity work, 1200$ for subgraph, 1000$ for tests)
• 8640$ for the "per-game" UI (3240$ for schema setup and initial implementation for SFA, Dropt, Battler and Strategotchi, 4400$ for UI, 1000$ for tests)

I will add to that amount a 15% contingency + bugfix fund, so we add 2900$, to get a grand total of 22240$. I have been in development for many many years so I know from experience that things do not always go as planned. I mention that contingency + bugfix fund separately because those additional 15% are kind of a safety reserve and if one month after final release it is not depleted, I pledge to send back whatever remains to the DAO.

I also pledge to post monthly updates stating how the project is going, and if it's still on track in terms of timing and budget.

Disbursement.

• 5000$ in stable on acceptance of the proposal
• 5000$ one month later.
• 5000$ 2 months later.
• 7240$ as a final payment 3 months later.

Schedule

If the proposal is accepted, the goal is to start as soon as possible with the "save and restore" system for gotchis, then the "Per-game details". Ideally I would like the development to spread on 2 to 3 months with one feature delivered every 4 to 6 weeks depending on my own workload.

Conclusion

I think the fact that PC let the DAO interacts with the official DAPP content through proposal is a unique opportunity we need to take as a community. I hope everyone see as much value as I do in that proposal ! As this is a sigprop, discussions are still open in the DAO thread. All comments and suggestions are still welcome.