MLabs – Cardano Game Engine Wallet - Godot Integration

[GENERAL] Name and surname of main applicant

[GENERAL] Email address of main applicant

Additional applicants

Sean Hunter

Ramiro Garay

[GENERAL] Please specify how many months you expect your project to last (from 2-12 months)

[GENERAL] Please indicate if your proposal has been auto-translated into English from another language.

[GENERAL] Does your project have any dependencies on other organizations, technical or otherwise?

[GENERAL] If YES, please describe what the dependency is and why you believe it is essential for your project’s delivery. If NO, please write “No dependencies.” .

No dependencies.

[GENERAL] Will your project’s output/s be fully open source?

[GENERAL] If NO, please describe which outputs are not going to be open source. If YES, please write “Project will be fully open source.”

Project will be fully open source.

[METADATA] Category of proposal

[IMPACT] Please describe your proposed solution.

Problem

Integration of Cardano blockchain technology into traditional video game products is a lucrative market that, we believe, has the potential to deliver concrete benefits to all parties involved. Users of video game products integrated with the blockchain stand to gain "real ownership" of their digital assets and identities. Developers of gaming products gain both additional monetization opportunities and, potentially, the ability to offload transaction logic onto the blockchain. The Cardano ecosystem benefits from increased adoption by ordinary users who may not have any interest in decentralized finance products.

However, as things stand now, integration is simply too costly and difficult to be viable for many game developers. A typical Cardano dApp (including both the on-chain and off-chain components) typically requires three components: 1) Smart contracts to be executed on-chain. 2) A browser-based light wallet that allows users to ergonomically interact with the dApp. 3) An application backend (plutus-apps, CTL, GeniusYield Atlas) that provides the "glue" (building transactions, applying arguments to parameterized scripts, balancing transactions, collateral creation or selection, etc) which facilitates a convenient experience for users interacting with the blockchain.

This architecture is not suitable for video game products. Although several game engines implement rudimentary embedded browsers, those embedded browsers are not fully-featured and cannot support the extension-based light wallets used in the conventional dApp architecture. While a game developer could (at least hypothetically) route interactions with the blockchain through a user's browser-based wallet, this leads to an awful experience for users who must configure a light-wallet outside of the game and break immersion (e.g. by "tabbing out") every time they seek to perform an in-game action that interacts with the blockchain.

If game developers wish to integrate Cardano's blockchain technology while maintaining ergonomics for the user, they must develop their wallet and integrate it into their engine of choice. It stands to reason that even game developers who are very enthusiastic about blockchain integration would hesitate in the face of this technical barrier (which falls well outside the expertise of a typical game developer).

Solution

We propose that the best solution to this problem is the obvious solution: Integrate light wallet functionality directly into a game engine while providing high-quality documentation and ample examples. This removes the largest barrier to entry facing game developers wishing to integrate Cardano's blockchain technology into their products.

We believe the Godot game engine represents the most promising avenue for wallet integration. Furthermore, we have been in talks with teams saying this could directly benefit them (for example, see here). Godot is an open-source engine, which greatly simplifies the work needed to quickly get wallet support up and running. Additionally, Godot is quickly gaining significant adoption, particularly among indie developers (who, we believe, are the most likely to develop innovative blockchain integrations and experiment with new designs and revenue models). Furthermore, because Godot is free and open source, there are no licensing requirements or fees attached to its usage - which makes it attractive even to large game studios. (We note that Godot has recently been used by a major studio to develop a Sonic game, which demonstrates that it is suitable for both small-scale and large-scale development). Finally, Godot supports a robust system for extending the core engine (GDExtension), which promises to make the development of Cardano integration tools relatively painless.

Of course, while light wallet functionality is necessary for blockchain/gaming integration, it is not sufficient for a maximally ergonomic developer experience; ideally, both the application backend and the light wallet would be tightly integrated into the engine. Furthermore, even with an application backend and light wallet in place, game developers without blockchain experience may still struggle, so a full solution to the problem requires that we integrate a wallet and/or application backend with tools that facilitate a familiar development experience for game developers.

Subsequent paragraphs in this section will address our strategy in technical detail, but in broad strokes, our approach is: I) Determine if CTL (Cardano Transaction Library, a dApp backend developed by MLabs that supports basic wallet functionality) can be bundled and made available as an extension. II) If CTL can be bundled as a Godot extension, bundle it. If CTL cannot be bundled, then [Lucid](https://lucid.spacebudz.io/) may be used, which is also fully featured and has a similar path for integration to Godot. Or, as a last resort, the Cardano Multiplatform Library (CML) can be utilized as a viable alternative to provide the bare minimum functionality required to implement a wallet. III) Test the extension and write high quality documentation for it. IV) Build upon functionality developed in previous steps to implement an integration with the Paima Engine, a high quality framework for developing blockchain-integrated gaming products, which will provide game developers with a familiar experience and reduce development time for Cardano-integrated gaming products even further.

Technical details

CTL is a Plutus application backend written in PureScript which can run either in a browser or node.js environment. In addition to its application backend functionality, CTL implements features necessary for minimal wallet functionality, and therefore a CTL extension to Godot would solve both the “client needs a wallet” and the “server needs an application backend” problems in one stroke.

Node.js provides a C++ embedder API (https://nodejs.org/api/embedding.html). Godot provides both an extension API (GDExtension) which supports C++, and a C++ "custom module API". Our research indicates that it should be possible to package CTL and bundle it either as a GDExtension or a C++ module, which we could then build upon (to improve ergonomics) and document. This is the optimistic "happy path" for the development of the project.

However, as every experienced developer knows, things that should be possible in theory can turn out unworkable in practice. Because we are committed to delivering a solution with our requested budget and in our requested time frame, we have a backup plan if bundling CTL is not a viable approach: Build our light wallet functionality on top of well-tested and widely-used core libraries.

CML (Cardano Multiplatform Library, written in Rust) provides the core functionality upon which wallets and other blockchain utilities can be built. Both of these libraries are widely used in the Cardano ecosystem and are presumed to be reliable (critical components of many dApps currently deployed to mainnet are built on top of one or the other).

We anticipate that building minimal wallet functionality on top of CML and bundling it as a GDExtension (for Godot v4) or a GDNative package (for Godot v3) can be accomplished very quickly. For a game-client wallet, a simple single-address wallet capable of signing transactions and sending funds to other wallets will suffice for the vast majority of use cases, and CML provides all of the necessary infrastructure to rapidly build this solution.

Given the nature of this project (which aims at reducing the complexity required to integrate the Cardano blockchain into gaming products), high-quality examples and documentation are every bit as important as the Godot modules/extensions. Consequently, producing those examples and documentation is an essential component of our proposal. A solution that only experienced Cardano developers can make use of is, in this domain, not much of a solution at all.

Finally, while we aim to provide a general solution to the problem, we acknowledge that simply implementing a Cardano wallet or CTL bundle for Godot is not likely to provide most game developers with sufficient tools to start building blockchain-integrated products. Consequently, we have partnered with the Paima team to integrate our wallet with their Paima Engine. The Paima Engine provides frameworks and tools that will enable game developers with minimal blockchain experience to immediately start building gaming products with blockchain integrations. We believe that this approach benefits the maximum number of users: Developers with significant blockchain experience may choose to implement a bespoke solution on top of wallet/CTL functionality, while developers without blockchain experience can make use of the high quality Paima Engine to do what they do best: Build awesome games!

Market

Amateur & professional game developers who wish to integrate Cardano with their products. Cardano developers who wish to branch out into gaming products. Indirectly, mainstream consumers of gaming products.

[IMPACT] How does your proposed solution address the challenge and what benefits will this bring to the Cardano ecosystem?

Intended Challenge – Developer Ecosystem - The Evolution

Challenge Question – "How do we equip and support developers with tools and working infrastructure? How do we make Cardano their first choice when it comes to building dApps, innovating and collaborating?"

What does this proposal entail?

We believe the scope of this proposal is eminently achievable with our requested budget and time frame. To recap from a previous section, our "happy path" only requires that we successfully bundle CTL and package it as a Godot module. Our "unhappy path" only requires us to implement very basic wallet functionality on top of well-tested and widely-used libraries. Basic light-wallet functionality is sufficient for integration with the Paima Engine, and we believe that Paima integration will be painless to accomplish. We only intend to integrate Godot’s web output with Paima’s JavaScript framework, and Godot provides well-documented tools for doing so.

How does integrating a wallet into Godot help developers?

At the moment, any developer wishing to integrate Cardano blockchain technology into a game product must develop their own wallet and bundle it into their application backend. We anticipate that a well-documented Godot wallet (and, optimistically, application backend) will greatly increase the number of game developers able to integrate Cardano technology into their products, which is very likely to foster innovation and experimentation and vastly increase the quantity and type of products that can be built on the Cardano blockchain.

[IMPACT] How do you intend to measure the success of your project?

Success for this project involves, at a bare minimum, releasing a light wallet extension for the Godot game engine along with very high quality documentation and examples. (Maximal success involves releasing an extension that supports both light wallet and application backend functionality, see answers to previous questions).

[IMPACT] Please describe your plans to share the outputs and results of your project?

We will share the progress and outcomes of our integration as effectively and transparently as possible using the typical channels:

• Dedicated GitHub Repository – As an open-source project for use by the community, our project outputs will be made available and regularly updated on a dedicated GitHub repository. This will provide easy access to interested developers.
• Community Updates – We'll regularly update the Cardano community on our progress and milestones through our social channels and regular Catalyst channels.
• Compliance and Documentation – MLabs has participated heavily in Catalyst in the past and has a strong track record of providing transparent and precise progress reports that are publicly available.

[CAPABILITY/ FEASIBILITY] What is your capability to deliver your project with high levels of trust and accountability?

MLabs, a leading consultancy in the Cardano ecosystem, has a proven track record and significant experience. Our team consists of seasoned engineers, each holding expertise in their respective fields. Moreover, we have consistently demonstrated our ability to deliver complicated projects with a high degree of trust and accountability. We have an extensive portfolio of satisfied client projects as well as several popular Catalyst projects. We're committed to upholding these standards for this integration proposal. Moreover, we are committed to working in an open-source and transparent manner.

[CAPABILITY/ FEASIBILITY] What are the main goals for the project and how will you validate if your approach is feasible?

The goals of the project are:

1) Providing a native Cardano light-wallet experience to the Godot engine. By native, it is meant that no out-of-game interaction will be necessary from the user to interact with the Cardano blockchain.

2) (OPTIONAL) Providing a Godot SDK for constructing Cardano dApps / games. The whole “off-chain logic” (the one related to building, balancing and signing transactions, among others) should be able to be scripted completely inside the engine. This goal is optional, since it depends on our success in integrating a fully featured JS library such as CTL or Lucid into Godot.

[CAPABILITY/ FEASIBILITY] Please provide a detailed breakdown of your project’s milestones and each of the main tasks or activities to reach the milestone plus the expected timeline for the delivery.

These are the expected milestones of the project:

1. Basic integration of chosen off-chain framework (1 - 1.5 months)
2. Wallet functionality implemented (1 month)
3. All off-chain functionality implemented (1 - 1.5 months)
4. Implemented extension API (1 month)
5. Documentation and examples complete (1 month)
6. Paima Engine integration complete (1-1.5 months)

Basic integration of chosen off-chain framework

Research on Godot’s extension systems and NodeJs / V8 embedding:

The first part of the project will involve research on Godot’s different extension systems and the NodeJs C++ Embedder API.

Setting up a development and build environment:

It is expected that a significant amount of work will be done on setting up a development environment that can build an embedded NodeJs runner as a shared library (for Windows / Linux at least) that can be used by Godot as a GDExtension. Some time will also be spent in bundling either CTL or Lucid as a single-file JS library.

Creating a C++ / Javascript internal interface for communication between CTL / Lucid and Godot:

A scheme will have to be devised for communicating between the NodeJs runner and the bundled Javascript library. This part is likely to be the most difficult due to lack of documentation and the necessity of interacting with Node and V8 internals. This task does not involve covering the entirety of CTL/Lucid’s API, but rather designing a sensible way of calling NodeJs code from within Godot. If this task proves to be too difficult, the optional goal will have to be dropped and the project will switch to integrating CML into Godot using the Rust bindings.

Testing the internal interface: With the internal interface in place, some testing will be performed: sending a TX to a testnet, creating a wallet from a seed-phrase, etc. These tests should serve as tangible evidence that the embedding approach is feasible. It should be noted that this interface is internal, and hence there are no requirements on how the extension looks like for a final user: here we only test how the extension internally communicates with JS-land.

Wallet functionality implemented

1. Implement the most basic operations expected from a light wallet: importing a seed phrase, signing a transaction, signing data, constructing simple Wallet-to-wallet transactions.
2. Implement other operations expected from a light wallet.

(OPTIONAL) All off-chain functionality implemented

1. Implement the most important operations expected from an off-chain SDK: querying addresses, constructing transactions (balancing, signing, submitting).
2. Implement other operations expected from an off-chain SDK.

Implemented extension API

1. Design and implement an ergonomic GDScript API: This task is concerned with designing and implementing a set of Godot “nodes”, with their own characteristic attributes, methods and properties, that will allow any interested party to add blockchain functionality in a way that integrates well with the rest of a video game. What Godot features (signals, nodes, resources, inheritance, etc.) to use is an open question; this task will be performed in parallel with the writing demos/examples, to test if our design gives a good UX. In this step, special attention will be placed on making the extension follow the standard conventions used in Godot game development.
2. Write a demos/examples making use of the extension API: The demo can showcase different expected uses of the technology. A couple of examples (not necessarily comprehensive): an in-game items store (represented on-chain as fungible/non-fungible tokens), token-based user authentication into a game server.

Documentation and examples complete

1. Documentation and examples: In order to assist developers who wish to make use of our project, we will create high-quality documentation for both the core wallet implementation and the extension API, making reference to the examples developed in the previous milestone. 

Paima Engine Integration complete

1. This task is concerned with building upon our wallet and extension API to add support for the Paima engine. Due to technical limitations, we only aim to incorporate Paima functionality into Godot web output builds by making use of existing Godot machinery for calling JavaScript code.

[CAPABILITY/ FEASIBILITY] Please describe the deliverables, outputs and intended outcomes of each milestone.

Basic integration of chosen off-chain framework:

Deliverable: A research writeup on Godot's extension system, a development environment, an interface scheme, and basic tests.

Outcome: NodeJS embedded in the Godot game engine and effective communication between the two systems established or a pivot to the Rust approach.

Wallet functionality implemented:

Deliverable: A basic light wallet integrated into the Godot game engine.

Outcome: Essential wallet features incorporated into the Godot game engine.

(Optional) All off-chain functionality implemented:

Deliverable: A complete off-chain SDK integrated into the Godot engine.

Outcome: More complex off-chain functionality incorporated into the light wallet and available to developers.

Implemented extension API:

Deliverable: An ergonomic and user-friendly API for the Godot extension.

Outcome: An intuitive GDScript API that smoothly integrates blockchain functionality into video games developed with Godot. Ample documentation, educational resources, and examples.

Documentation and examples complete:

Deliverable: Detailed, comprehensive, and user-friendly documentation and descriptive use case examples.

Outcome: Developers have a clear and practical understanding of how to incorporate the extension into their projects.

Paima Engine integration complete:

Deliverable: Successful integration of the Paima engine into the Godot game engine, with blockchain functionality available.

Outcome: Increased scope and usability of blockchain functionality within the Godot engine, opening up additional opportunities for developers to create innovative, blockchain-based gaming experiences.

[RESOURCES & VALUE FOR MONEY] Please provide a detailed budget breakdown of the proposed work and resources.

Basic integration of chosen off-chain framework: 250 hours

Wallet functionality implemented: 180 hours

All off-chain functionality implemented: 250 hours

Implemented extension API: 160 hours

Documentation and examples complete: 120 hours

Paima Integration: 250 hours

Subtotal: 1210 hours @95/hour = $114,950 USD

Total (@ rate $0.21 USD / ADA): 547380 ADA

**In the interest of full transparency, please note we have applied a conservative USD/ADA exchange rate in pricing this proposal. This is to ensure our operations remain stable regardless of market conditions. Although we firmly believe the future of Cardano is bright, we recognize the price of ADA and all cryptocurrencies is inherently volatile. Our financial obligations are denominated in fiat. Most importantly, this includes the salary of our engineers whose hard work makes projects like this possible. 

In the unlikely scenario of severe negative price movement beyond our forecasted rate, it is possible that MLabs may need to temporarily suspend work on this proposal until the market recovers. Rest assured, this decision would be made solely to protect our business's long-term viability and never taken lightly. 

We appreciate your understanding and support, and we are excited to see what we can achieve together.

[RESOURCES & VALUE FOR MONEY] How does the cost of the project represent value for money for the Cardano ecosystem?

Our project, which centers on integrating a light wallet into the widely-adopted Godot game engine, serves as a key enabler for Cardano's expansion into the burgeoning gaming industry. Recognized for its rapid growth and influential trend-setting dynamics, the gaming industry presents an outstanding platform for Cardano's widespread adoption.

This project will empower game developers with easy access to Cardano's rich feature set, inspiring a conducive environment for creativity and innovation to flourish atop the Cardano blockchain. We anticipate this integration will directly lead to an enriched gaming experience underpinned by the decentralization, transparency, and security inherent to Cardano.

From a value-for-money perspective, the Catalyst community stands to gain significantly. Primarily, the project provides a promising financial ROI, as the gaming industry represents a fertile ground for growth. More importantly, the successful delivery of this project symbolizes tangible, real-world applications paving the way for a stronger, more influential Cardano ecosystem.

[IMPORTANT NOTE] The Applicant agreed to Fund10 rules and also that data in the Submission Form and other data provided by the project team during the course of the project will be publicly available.