Comment on page


What is a Persona?

Personas are digital identities; they portray a name, a profile picture, bio and linked avatar. Through our services game developers are able to pull data from these personas; using the end-user wallet as a query parameter. This allows it to carry a single identity across multiple games. The authentication method to access these persona’s is wallet based.

What is a Smart Contract?

A "smart contract" is simply a program that runs on the Ethereum blockchain. It's a collection of code (its functions) and data (its state) that resides at a specific address on the Ethereum blockchain.
Smart contracts are a type of Ethereum account. This means they have a balance and they can send transactions over the network. However they're not controlled by a user, instead they are deployed to the network and run as programmed. User accounts can then interact with a smart contract by submitting transactions that execute a function defined on the smart contract. Smart contracts can define rules, like a regular contract, and automatically enforce them via the code. Smart contracts cannot be deleted by default, and interactions with them are irreversible.

What are the different standards Emergence Supports and what does this mean to me as a Developer?

The Ethereum community has proposed and implemented several standards; these begin as proposals referred as EIP's, and when these are application-level standards and implemented, they are referred as ERC's.
The most popular standards nowadays are the token standards: ERC20, ERC721 and ERC1155.
This enables developers to build interoperable applications, and allows users to move and interact with their assets through an ecosystem of decentralized apps and games.

What is our plan for upcoming releases?

We kicked-off our closed beta in March 2022, with a handful of developers who were part of our early access testing with the Emergence SDK. Based on the feedback from our Developers, we expanded upon our SDK and launched our Open Beta in September 2022. If you are interested in sharing any feedback with us for future versions, don’t hesitate to reach out to us on our Discord. We also have a public board where you can request features, fixes, etc. And contribute to the public discussion and vote on features others have asked for. https://open-meta.canny.io/emergence You can also see a glimpse at our current Roadmap planning here.

How do I report a bug, issue or suggestion?

You can send bugs, issues and suggestions in our discord! If you are reporting a bug, we usually will need the log file to understand what happened. If the crash was after the editor has opened, we'll probably need the log from this location: Windows / Mac:
<Project folder>/Saved/Logs/<project name>.log
If the crash happened while the plugin was being built by the editor (if you are building from source), or the plugin couldn't be compiled when you tried to open it, we we'll need the log from this location: Windows:
%USERPROFILE%\AppData\Roaming\Unreal Engine\AutomationTool\Logs\<Engine version>\log.txt
~/Library/Logs/Unreal Engine/LocalBuildLogs/

How We Store Data & Plans for the Future

The information associated to personas is currently being stored in DynamoDB, this is because we don't want first time users to be forced to pay an initial gas fee.
In the future we have plans to turn this database into a premint registry, so users can then mint their personas into a Polygon smart contract and claim a unique name if they wish to.
We are also exploring decentralized alternatives to DynamoDB like ThreadDB, BigChainDB, etc.

Why EVM compatibility?

Ethereum took the leap as a technology and evolved into an ecosystem of developers, open source tools and applications, communities and even multiple networks.
The Emergence SDK is EVM compatible, this means that you can connect to any EVM node, Ethereum, Polygon, Tron, Binance Smart Chain, xDai, Arbitrum, Solana (testnet), and so on

What tokenomics do we support in the Emergence SDK?

We support any tokenomics model; this is because we are almost fully compatible with EVM networks, meaning that you can interact with your own smart contracts.

Do we support ERC-1155? What is our approach and what should Game Developers consider for their designs?

Yes. We support most smart contracts; including the ERC1155 standard.
The approach can vary depending on the needs, given that our tool can run natively in Unity you have the possibility of performing read methods directly to contracts from a game server instance; this might be useful for some cases where the security is critical (eg. allowing access to your game, or choosing an item at the begging of a round), but not ideal for all use cases because of the response times (100ms-1000ms depending on the network and network conditions, eg. Ethereum, Polygon, almost any EVM network).
We can also help set up an off-chain server to index on-chain data, in order to be able to perform faster queries, of course, at the expense that the data may not be up-to-date.
Developers need to be aware of the contracts that they choose to develop or/and interact with and being able to design the correct architecture for their needs.
Custom JSONs are needed for handling contract ABI’s. We provide examples for this.

As a Game Developer, where does the Emergence SDK sit in a typical Tech Stack? How should game devs be using this and what are specifics they should be aware of?

The emergence SDK is distributed as a plugin, it is available for Unreal & Unity. Game developers can then perform on-chain tasks, and provide authentication through wallet signing or on-chain data, we also provide off-chain services for managing user profiles and a user interface to handle everything related to them, the authentication method for our off-chain services is wallet based.
You can see a full diagram of our current and future architecture here.

As a game developer using the Emergence SDK, what should I be aware of for onchain vs offchain assets?

Onchain assets that comply with standards (erc-20, erc-721, erc-1155) have the benefit of interoperability, meaning that these assets are normally liquid (easily exchangeable), and given that they have a set of standard methods; it’s easy for 3rd party developers to then interact with them in any kind of application, of course that depending on the network of choice, the network effect can vary; example: Opensea currently supports Ethereum and Polygon.
Off Chain assets/data can still be useful for items that we don’t necessarily consider of value or have the need to live in a blockchain. Below we provide an example of a hybrid model; which is widely used.

How can I think of using on-chain attributes in a game?

Example: I have a sword that is damaged. Does that reduce the “worth” of the item on-chain? Example: I have a car that I upgrade in game, how do those attributes get saved on-chain? Example: Can a gamedev think of a whole experience, a game world, as something that gets saved on-chain?

These are high level architecture questions and the answer for each of them can really vary depending on the needs and the business model of the game. To answer your question, everything above is possible, Solidity is a turing complete language. Here are some examples:
Solidity has the concept of mappings (normally used for attributes) which can be structs or just single data types (bool, int, array, etc), these can be used to relate a tokenID to something. In the sword case, we could have an NFT that has a “Damaged” attribute, which could be a boolean that gets triggered by X action.
For a car upgrade or even a whole game world, you could consider more complex types.
The possibility of a ‘hybrid’ model also exists; where you can represent something with extremely high-level on-chain (for example: ‘a magic sword’) but you can also relate off-chain data for your game for that given on-chain asset, so you would know in your centralized database that tokenID:123 is damaged, or you could just save a screenshot or a placeholder on-chain, but store an entire game-world related to it off-chain. This is widely used and normally accepted by the community. There are also standards for storing off-chain data, so it’s easily recoverable by 3rd party applications (eg. opensea).