Creation of your Game Address

Every game uses a Game Address, which acts as a routing mechanism for in-game transactions. This address will be your game's wallet that receives the funds collected (your profit) from sales or a percentage of transactions or any other mechanics you have chosen.

It's important to note that funds can be withdrawn with a 7-day delay. This delay allows us to verify that a legitimate pattern has been used in the game and that no fraudulent activity has been generated.

How to create a ZooGamesID with METAMASK (recommended)

Once your game fully utilizes the Testnet functions of the protocol, we will provide you with a Mainnet API Key for the final release of your game.

The use of the protocol is free; however, transaction fees are automatically deducted to generate additional rewards for players (GameStake).

SDK installation

To interact with our API, we recommend installing our official SDK, which provides the best integration with our system. This SDK simplifies the process of connecting to our API and provides pre-built functions and tools to facilitate development.

Please follow the installation instructions provided in the documentation specific to your chosen SDK. This will ensure that you have the necessary libraries and dependencies set up correctly in your development environment.

By using our official SDK, you can streamline the integration process and take advantage of the features and functionalities we offer in a more efficient and effective manner.

# Install via NPM
npm install --save zoo-game-sdk

Testnet Faucet

We have developed a straightforward testnet faucet that allows you to request testnet vZOO tokens.

Let's start with "Authentication"

Welcome to ZOOGAMES

The ZooGames API enables communication between your game and the blockchain. It allows you to create in-game transactions using vZOO tokens, retrieve NFT data regardless of the original chain, implement a simple and secure authentication system, and mint in-game chips or NFTs.

The protocol is constantly evolving, and we are working on several features such as cross-chain messaging (interacting with a target chain through the ZooGames API) and the integration of your gaming token into our ecosystem for a simple and free system.

By seamlessly integrating with all EVM networks, ZooGames offers users the freedom to connect, play, and earn across a range of networks such as Ethereum, Binance Smart Chain, Avalanche, Wanchain, and more.

Once connected, the ZooGames protocol automatically generates a unique mirror address (Gaming Wallet) exclusively for gaming purposes. This mirror address, created on the Wanchain network, acts as a replica of the user's primary address (and any linked secondary addresses) and facilitates seamless participation within the gaming environment.

ZooGames empowers players with a versatile and interoperable gaming experience, where blockchain technology enhances security, transparency, and ownership of in-game assets.

Want to jump right in?

1. Basic concept

Before implementing the GameSettle API, let's start with a basic concept of game settlement. Imagine you want to develop a simple card game where four players participate.

Each player needs to spend 100 vZOO to join the game, resulting in a total of 400 vZOO in the game pool. At the end of the game, the winner receives 200 vZOO, the second-place player receives 150 vZOO, the third-place player receives 50 vZOO, and the fourth-place player receives nothing. You can use the game settlement API to broadcast the vZOO rewards each player has obtained.

In the game lobby, Player #1 joins. The game server calls the "Game/Ready" API to check Player #1's vZOO balance. If the balance is sufficient, the player is verified and remains in the lobby. If not, the player is kicked out.

• Player #2 joins but doesn't have enough vZOO to play. The game server removes this player from the lobby.

• Players #3, #4, and #5 join with sufficient vZOO to play.

• With four players ready, the game server calls the "Game/Start" API to initiate the game. This API transfers their 100 vZOO to the locked vZOO pool, totaling 400 vZOO.

• After gameplay, the final vZOO amounts for each player are as follows:

  Player #3 (Winner): 200 vZOO

  Player #4 (Second place): 150 vZOO

  Player #1 (Third place): 50 vZOO

  Player #5: 0 vZOO

• The game server needs to call the "Game/Over" API with the round ID and provide the player reward information in the order they entered (from "Game/Start"), such as [50, 200, 150, 0].

2. Adding Developer Fees

If you want to receive a fee from each game, for example, 5%, you can deduct this percentage from what each player receives.

After the gameplay, the final vZOO amounts for each player are as follows:

• Player #3 (Winner): 200 vZOO

• Player #4 (Second place): 150 vZOO

• Player #1 (Third place): 50 vZOO

• Player #5: 0 vZOO

To calculate the developer fee, deduct 5% from each player's amount:

• Player #1: 49 vZOO (2.45 vZOO as dev fee)

• Player #3: 196 vZOO (9.8 vZOO as dev fee)

• Player #4: 147 vZOO (7.35 vZOO as dev fee)

• Player #5: 0 vZOO (0 vZOO as dev fee)

The total developer fee is 19.6 vZOO, and the final broadcast amounts become [46.55, 186.2, 139.65, 0]. The game server simply calls the "Game/Over" API with the new final broadcast [46.55, 186.2, 139.65, 0] and provides the gameResultAmount as 19.6.

3. Top-Up extra reward

If you want to offer additional vZOO as promotional rewards to encourage users to play your game, you can top-up the locked vZOO pool. Assuming you want to support an extra 100 vZOO for each game, with four players ready to start the game, the game server can call the "Game/Start" API with a gameLockAmount of 100 vZOO. The total locked vZOO in the pool will then be 500 vZOO. After gameplay, the final vZOO amounts for each player are as follows:

• Player #3 (Winner): 200 vZOO + 50 vZOO (extra)

• Player #4 (Second place): 150 vZOO + 40 vZOO (extra)

• Player #1 (Third place): 50 vZOO + 10 vZOO (extra)

• Player #5: 0 vZOO

The game server needs to call the "Game/Over" API with the round ID and provide the player reward information in the order they entered (from "Game/Start"), such as [60, 250, 190, 0]. Each reward amount should be reduced by the platform fee (assumed to be 2%). Therefore, the final broadcast amounts will be [58.8, 245, 186.2, 0].

You can also adjust the developer fee in this section. However, ensure that the total paid amount plus the platform fee is less than the total locked vZOO in the pool. From the game server side, you have the flexibility to mix and match these concepts as desired.

For your projects, we provide two different API endpoints based on the network you intend to utilize:

Mainnet API Endpoint

This endpoint is specifically designed for integration with the mainnet network. It enables you to interact with the ZooGames API in a production environment, where real transactions and operations occur. You should use the Mainnet API Endpoint when your project is ready for deployment and needs to interact with the live blockchain network.

Testnet API Endpoint

This endpoint is intended for use on the testnet network. The testnet environment allows you to experiment and test your integration with the ZooGames API without utilizing real funds or affecting the live blockchain network. It provides a sandbox-like environment for developers to ensure the functionality and reliability of their applications before transitioning to the mainnet.

Please ensure that you select the appropriate API endpoint based on your project's requirements and the desired network environment.

A ZooGamesID is a unique identifier that represents a player's identity on Zoo.Games. When a player starts a ZooGames compatible game, they enter their ZooGamesID to link their profile to the game.

Each ZooGamesID utilizes 2FA (Two-Factor Authentication) for approving transactions within the game. The 2FA authentication process ensures an additional layer of security and requires the player to provide a second form of verification, typically through a mobile app or email, before authorizing any in-game transactions. This helps prevent unauthorized access and ensures that players have control over the transactions associated with their ZooGamesID.

A Mirror address, also known as a Gaming Wallet to players, is an address created by the protocol on Zoo.Games. It serves as a connection point between the API, games, and the platform. All in-game transactions are associated with the mirror address.

A Primary Address is the main address chosen by the player to link to their ZooGamesID. This primary address is used for all interactions with the ZooGames protocol.

A Secondary Address is an optional feature that allows players to connect additional addresses to their profile. It enables them to link assets from other wallets to their ZooGamesID.

More info on our v1 concept paper:

On ZooGames, players have two primary methods to log in and access the platform:

Both methods are designed to provide flexibility and ease of access, catering to both seasoned gamers and newcomers alike.

Concept

Instant PlayPass is a streamlined onboarding feature for ZooGames. With just a username, players can instantly dive into games without initially setting up a ZooGamesID. Behind the scenes, two addresses (a primary and a mirror gaming address) are auto-generated for the player.

This lets newcomers freely explore games, earn tokens, and collect NFTs.

Technical Overview

Automated Address Generation Upon entering a game, users will only be required (or not — depending on the game developer’s chosen settings) to input a username. In the backend, the ZooGamesAPI will generate two distinct addresses for the user: a primary address and a corresponding gaming (mirror) address.

Gaming Experience & Asset Accumulation Users can immediately immerse themselves in the gaming environment, earning tokens, in-game chips, and NFTs, all of which are compatible across multiple blockchains, ensuring interoperability and flexibility.

Private Key Retrieval & Integration After the creation of their ZooGamesID, users will have the possibility to securely download the private key associated with their temporary primary address. This key can then be integrated as a secondary address within their newly minted ZooGames account, ensuring continuity and security of assets.

Create in-game PlayPass Accounts

Grant your players instant access to your game using Instant PlayPass.

Create a new PlayPass account

POST API_END_POINT_URL/API_KEY/register/temp_user

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Request Body

{
  success: true,
  data: {
    jwt: 'eyJhbGciOiJIUzI1NiIsInR5pXVCJ9.eyJ1c2VybmFtZSI61MDIxOTcxMjE2IiwicHJpbWFyeUFkZHJlc3MiOiIweDY1MkFhMjM1NWM3MDAzNjVhNUY4ZDI5YzFlOGY1NWFlRjI1RjAyQWYiLCJtaXJyb3JBZGRyZXNzIjoiMHgyZjAyOThhMDEyMjY4RkNiNDY4ZmM0OTE3MDI2NTk5OUQ4RWJmQ0ZhIiwibWlycm9yQmFsYW5jZSI6IjAiLCJjaGFpbklkIjo4ODgsImNyZWF0ZVRpbWUiOjE2OTUwMjE5ODE1MDksImF2YXRhcl91cmwiOm51bGwsImlzVG1wIjp0cnVlLCJhcHByb3ZhbCI6OTk5OTk5OTk5OSwicGxheVNlY29uZHMiOjk5OTk5OTk5OTksInN0YXJ0VGltZSI6MTY5NTAyMTk4MSwiZW5kVGltZSI6OTk5OTk5OTk5OSwiZ2FtZUFkZHJlc3MiOiIweDVEMkE4QjM2ODMyOTI0NDJmQUNhNTJlOUI2NTM3RmFhYWQwQUU1NzYiLCJpYXQiOjE2OTUwMjE5ODJ9.AI-xg0hdQ-4vwK8ffgBiuUXKIE1dMKl0TXU7ZFwYh6o',
    username: 'TMP_1695021971216',
    gameAddress: '0x5D2A8B3683292442fACa52e9B6537Faaad0AE576',
    primaryAddress: '0x652Aa2355c700365a5F8d29c1e8f55aeF25F02Af',
    mirrorAddress: '0x2f0298a012268FCb468fc49170265999D8EbfCFa'
  }
}

{
  "success": false,
  "message": "error message",
}

Uncover the redeem code for the PlayPass account

When players decide to transition to a web3 wallet, they can claim their wallet credentials using a redeem code.

Provide a confidential redeem code, allowing users to register on Zoo.games

POST API_END_POINT_URL/API_KEY/reveal/mirrorRedeemCode

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Request Body

{
  success: true,
  data: {
    username: 'TMP_1695021971216',
    gameAddress: '0x5D2A8B3683292442fACa52e9B6537Faaad0AE576',
    primaryAddress: '0x652Aa2355c700365a5F8d29c1e8f55aeF25F02Af',
    mirrorAddress: '0x2f0298a012268FCb468fc49170265999D8EbfCFa',
    redeemCode: 'CD18-F930-57H2-756F',
    redeemUrl: 'https://zoo.games/signup?redeemCode=CD18-F930-57H2-756F'
  }
}

{
  "success": false,
  "message": "error message",
}

Get User's Info

The User API serves the purpose of retrieving essential information about a user in the ZooGames API. It provides details such as the user's ZooGamesID, EVM addresses (primary, secondaries and mirror), their respective balances, the chain ID, the number of successful 2FA verifications, the creation time, and an optional avatar. This information can be used for user identification, account management, displaying user profiles, and tracking user activities within the gaming platform

Get Basic Info by ZooGamesId

GET API_END_POINT_URL/API_KEY/userInfo/username/[ZOO_GAMES_ID]

Path Parameters

Query Parameters

Get Basic Info by Primary address

GET API_END_POINT_URL/API_KEY/userInfo/primary/[PRIMARY_ADDRESS]

Path Parameters

Query Parameters

Get linked secondary addresses by Primary Address or ZooGamesID

GET API_END_POINT_URL/API_KEY/secondary/[PRIMARY_ADDRESS or ZOO_GAMES_ID]

Path Parameters

Get user profile image directly

GET API_END_POINT_URL/api/user/profile_pic/[ZOO_GAMES_ID]

If there have some image set. It will return base64 encoded image. No profile image or not found a user by ZOO_GAMES_ID will return an "Empty".

Path Parameters

This solution allows users to utilize their vZOO tokens to buy or sell in-game items and assets. The game services and game address play a crucial role in facilitating these transactions and providing control over the process.

This solution can be applied in various scenarios:

1. Purchasing In-game NFTs (ERC721) with vZOO:

   • Users can spend a specific amount of vZOO.

   • A new ERC721 token is minted and transferred to the user.

2. Purchasing In-game Tokens (ERC20) with vZOO:

   • Users can spend a certain amount of vZOO.

   • A new ERC20 token is minted and transferred to the user.

3. Acting as a middleman for user-to-user trades:

   • Users can transfer vZOO from User A.

   • The gameTrade API is called to facilitate the trade.

   • ERC20 tokens are transferred or burned, and ERC721 tokens are minted or transferred between User B and User A.

   • The gameTrade API is called again to send the locked amount from User A to User B.

In summary, this solution enables the seamless exchange of vZOO, ERC721 tokens, and ERC20 tokens between users, with 2FA verification ensuring secure and authenticated transactions.

GameTrade

Initialize ERC721 before using the token

POST API_END_POINT_URL/API_KEY/game/trade

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

The platform fee of 2% is automatically collected on every vZOO transactions within the ZooGames ecosystem.

These collected fees are then directed towards the GAMESTAKE feature, which is designed to reward dedicated and enthusiastic players within the ecosystem.

Learn more about GAMESTAKE

By using the faucet, you can acquire the necessary testnet vZOO tokens to simulate transactions and test various functionalities within the testnet environment. Please note that the amount of testnet vZOO tokens you can request is limited to 1000.

Concept

The player provides their ZooGamesID and 2FA token, and if the credentials are valid, the server grants access for the user to log in.

A user's session in the application has an expiration time of 120 minutes. After this period, the session will expire, and the user will need to log in again.

If the user wants to extend the session and prevent it from expiring, they can use the Keep-alive API. By making a request to the Keep-alive API within the session's duration, the session will be refreshed, and the expiration time will be extended.

To gain insights into how authentication works on Zoo.Games, you can explore our open-source Telegram AUTH web app. It will provide you with a clear understanding of the authentication process implemented on the Zoo.Games platform.

To authenticate and handle login and logout functionality, you need to follow these steps:

Login and Logout

by installing the SDK and utilizing the signData() function, you can generate the SignedSignatureFromPayload (HMAC signature) for authentication purposes in the ZooGames API requests

Login API - To Login user and return JWT token as a session token

POST API_END_POINT_URL/API_KEY/session/login

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Headers

Request Body

Logout API - To log out for already log in user

POST API_END_POINT_URL/API_KEY/session/logout

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Headers

Request Body

Keep-alive

The Keep-Alive feature allows users to extend the expiration time of their session. By making a request to the Keep-Alive API endpoint within the session duration, users can refresh the session and prevent it from expiring.

Keep-alive API - To keep alive (Persistent Session) logged in user

POST API_END_POINT_URL/API_KEY/session/keepAlive

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Headers

Request Body

Keep-Alive helps enhance user experience by reducing the need for repeated logins and provides convenience during extended usage periods.

Approve

Approve API enables the creation of in-game vZOO transactions. However, to ensure security and validate the transaction, players are required to re-enter their 2FA (Two-Factor Authentication) credentials.

If the 2FA validation fails or is not provided by the player, the transaction will not be approved and will result in a failure.

Approve API - To request vZOO spending from user mirror address

POST API_END_POINT_URL/API_KEY/session/approve

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Headers

Request Body

Status

The Status API returns the current JWT Payload and verifies whether their JWT is eligible for use in the Settlement API.

Status API - Returns current JWT Payload and verifies current JWT

POST API_END_POINT_URL/API_KEY/session/status

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Headers

Request Body

Query String

Login and Approve

When users interact with the Login and Approve API, they are required to provide their login credentials, ZooGamesID and 2FA, to authenticate themselves and gain access to their account. Upon successful authentication, users can proceed to approve in-game transactions.

If the 2FA validation fails or is not provided by the player, the transaction will not be approved and will result in a failure.

Login and Approve API - to Login and Approve at once

POST API_END_POINT_URL/API_KEY/session/loginAndApprove

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Path Parameters

Headers

Request Body

Random Number Generator

The RNG service in this gaming API provides randomness for various aspects of the game, ensuring fairness, unpredictability, and security. It adds excitement, prevents bias, enhances game balance, and deters cheating.

Simple Random Number Generator function return with array of HEX number

GET API_END_POINT_URL/API_KEY/random/RNG_LENGTH/RNG_COUNT

Query Parameters

{
    "success": true,
    "data": [
        "324fe8b8a143c83a03131b6d80cb6fe2",
        "5dfeb015a94d0952534c92fd5cc5d6a9",
        "d7c4b41bc0ea88a56bd6cd51f878fcb5",
        "f98855bd84800bb0c0ef7ce9fba09ef4"
    ]
}

{
    // Response
}

Randomness function + Seed String

You can use Seed String to always generate fixed results.

GET API_END_POINT_URL/API_KEY/random/RNG_LENGTH/RNG_COUNT/SEED_STRING

You can utilize a future Block Hash as a seed to obtain an unpredictable but verifiable random number. The result will always be consistent with the provided seed string.

Query Parameters

{
    "success": true,
    "data": [
        "689957ac83b4dc6a8c11c61cb9717484",
        "39f1d2aa5f7cef567996e26fd09ccc37",
        "f877260c00449810e5a89442068105a3",
        "0bb6827d0d4d9687e0da04a78cb2c4cc",
        "c5e12dd1ad8b58989883a422cd6ae1d2"
    ]
}

{
    // Response
}

Use Cases

1. Gameplay Mechanics: Many games rely on random elements, such as random encounters, loot drops, critical hits, or chance-based events. The RNG service provides a source of randomness to determine the outcomes of these events, making the gameplay more exciting and unpredictable.

2. Fairness in Competitions: In multiplayer or competitive games, the RNG service can be used to ensure fairness among players. For example, when determining matchmaking, allocating resources, or deciding turn orders, randomization helps prevent bias or favoritism and creates a level playing field for all participants.

3. Security and Encryption: Randomness is crucial in cryptographic operations and security protocols. The RNG service can generate random cryptographic keys, initialization vectors, or nonce values, which are essential for encryption, secure communications, and preventing unauthorized access.

4. Game Balance and Variability: Randomness adds an element of variability to the game, preventing repetitive patterns and creating unique experiences. By incorporating random elements, the game becomes less predictable, enhancing replayability and player engagement.

5. Anti-Cheating Measures: RNG can be used to deter cheating or exploit attempts within the game. For instance, randomizing critical game values or outcomes makes it harder for players to manipulate or predict results through unauthorized means.

By utilizing an RNG service within the ZooGames API, developers can ensure that the game's outcome is determined in a fair, unbiased, and unpredictable manner. It enhances the gaming experience, maintains game balance, strengthens security measures, and fosters a more enjoyable and competitive environment for the players.

Current vZOO / ZOO Price

In the context of this gaming API, an Oracle price of the vZOO token serves an important purpose. The vZOO token is the native token used within the game ecosystem, and its value can fluctuate in the market.

The Oracle price refers to a periodically updated price of the vZOO token, which is obtained from an external data source such as Coingecko or CMC. This price information is then utilized within the gaming API for various purposes, such as:

1. Game Settlement: When settling game transactions involving the vZOO token, the Oracle price is used to calculate the value of rewards, prizes, or in-game assets in terms of the vZOO token. This ensures fair and accurate distribution of rewards based on the current market value of the token.

2. Pricing Mechanics: The Oracle price can be utilized to determine the pricing of in-game items, upgrades, or services that are purchased using the vZOO token. By considering the current market price, the game can maintain a balanced economy and adjust the pricing accordingly.

3. Exchange Rates: If there are interactions or transactions between different tokens or currencies within the game ecosystem, the Oracle price of the vZOO token can be used to establish exchange rates or conversion ratios. This enables seamless conversions and consistent valuation across different token types.

By integrating an Oracle price of the vZOO token into the gaming API, developers can ensure that the in-game economy accurately reflects the real-world value of the token. It enhances the transparency, fairness, and consistency of game mechanics related to the vZOO token, providing a more engaging and reliable gaming experience for the players.

Get the current price of ZOO / vZOO

GET API_END_POINT_URL/api/price/ZOO

We recommend using the Mainnet API to fetch the current price.

{
"success": true,
"symbol": "ZOO",
"price": 0.004199399631770368
}

ZooGames provides the opportunity to integrate any NFT collection from most EVM chains.

Currently, we offer a manual process for adding your NFT collection to our platform, and we are actively developing a fully autonomous solution.

If you're eager to get started, please contact us and provide the following information: the EVM chain, contract address, and token name (alias name) of your NFT collection.

Once your collection is added to our system, we will provide you with an API endpoint to access and utilize the collection within ZooGames.

21/12/2023

• Add new Game Settlement API

23/10/2023

• Create an Info of Hotlink to register with reveled redeem code.

16/10/2023

• Add direct get User's Profile Image

25/09/2023

• isTMP flag has been changed to isPlayPass

18/09/2023

• Add Temporary Accounts Features
• Add isTmp and createdFromRedeemCode to userInfo api

25/08/2023

• Add Query string "without_avatar" to reduce the size of returning data

  • Users

The ZooGames WebApp code is also completely free and open-source, so developers can customize and integrate it into their games and apps without any extra cost or hassle.

In short, ZooGames’ revolutionary system simplifies gaming authentication and offers a secure and easy way to access your gaming data. So, why not give it a try and experience the future of web3 gaming authentication?

Please check out our Github:

Example of use case

Prerequisite

5. The Vercel service can be used to host your WebAPP.

Flow of Authentication

The authentication flow involves the display of a login form on the WebApp. Upon successful connection to the right MongoDB and input of the user's Telegram ID, a JWT Token will be recorded as the following structure:

The user will also receive a direct message from the bot, containing their logged in Zoo.Games ID, Primary Address, and Mirror Address. If there are any errors, an alert will be displayed to prompt the user to fix it.

You can continue writing your BOT code to get TG user id, username and ZooGames JWT for further gameplay.

BOT Code

To call the Telegram Webapp, the sendMessage and sendPhoto APIs can be used with a reply markup of inline_keyboard. It is important to note that the Bot Menu should not be used to call the WebAPP, as it will not send a query of User Data to the WebAPP. The following environment variables structure can be used:

ENV Structure of TESTNET

ENV Structure of MAINNET

This pack is perfect for game developers looking to add unique, cartoon-style animal characters to their projects. It also includes a variety of accessories, such as hats and glasses, that can be used to customize the animals and make them even more unique.

This is a great opportunity for developers to save time and resources by using these pre-made assets, instead of having to create them from scratch. Get your hands on this pack today and take your game development to the next level!

Link to the asset pack

Don’t forget to credit the ZooEcosystem team when using it!

In-Game NFTs are ERC721 tokens that offer transparency in minting and transactions. They enable games to create virtual assets without the pain of deploying a smart contract. Developers can easily create In-Game NFTs using ZooGames API and control them securely.

Use Cases

1. Virtual Assets: Earn or purchase In-Game NFTs for in-game items, upgrades, or unlocking levels.

2. In-Game Economy: engage in player-driven economies within the game.

3. Reward System: Distribute NFTs as rewards for achievements, competitions, or milestones.

4. Social Interaction: Gift or trade NFTs, foster community engagement.

5. Airdrops and Promotions: Airdrop NFTs to players, attract new users or introduce special events.

6. Limited Edition Collectibles: Create rare NFTs for trading and collecting.

Initiating In-Game NFTs Creation

To create an In-Game NFTs token using the ZooGames API, you can follow these steps:

1. Send a request to the API endpoint, providing the desired Token name and symbol in the request payload.

2. The API will process your request and generate a new In-Game NFTs token with the specified Token name and symbol.

3. Upon successful creation, you will receive a response containing relevant information about the newly created token, such as its contract address and other necessary details.

4. You can now incorporate this In-Game NFTs token into your game environment, allowing players to interact with and own unique virtual assets.

Initialize ERC721 before using the token

POST API_END_POINT_URL/API_KEY/erc721/create

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

Batch Mint

This function empowers game developers to generate new NFT tokens on-demand, granting them flexibility and control over the in-game economy. You have the ability to mint NFTs in batches using an array.

Mint Tokens by batch

POST API_END_POINT_URL/API_KEY/erc721/batchMint

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

Batch Burn

This function enables game developers to remove existing NFT tokens from circulation, granting them control over the in-game economy and token supply. You can burn NFTs in batches using an array, effectively eliminating them from the system and ensuring their scarcity and value.

Burn Tokens by amount from ZooGamesID

POST API_END_POINT_URL/API_KEY/erc721/batchBurn

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

Total Mint count

The Total Mint Count API retrieves the total number of operations in your collection. By making a request to this API, you can obtain the count of NFTs operations that have been minted for a specific collection, providing valuable information about the size and scale of your collection.

Token Minted Counter operation (Not NFT supply)

POST API_END_POINT_URL/API_KEY/erc721/totalMintCount

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

Get user In-Game NFTs

The Get In-Game NFTs API allows you to retrieve In-Game NFTs based on either the user's ZooGamesID or their Primary Address. You can use this API to obtain multiple NFT collections associated with a user, providing access to their owned NFTs within the game ecosystem.

Retrieve the list of In-Game items based on the ZooGamesID or Primary Address.

GET API_END_POINT_URL/API_KEY/userInfo/nft/inGameNft/[ZooGamesID or Address]

Example:

Query Parameters

In-Game Chips are ERC20 tokens, which means they offer minting and txs transparency that traditional web2 game currencies can't match. This new token helps games create virtual currencies without providing liquidity to an exchange market.

Developers can create In-Game Chips with ZooGames easy-to-use interface and control them with complete security using the ZooGames API. With In-Game Chips, players can earn chips by completing missions or buy chips in packs. They can even be airdropped to mirror addresses on ZooGames. In short, In-Game Chips are the future of gaming and a key element of the Web3 gaming experience.

Use Cases

1. Virtual Currency: In-Game Chips can be used as a virtual currency within the game ecosystem. Players can earn In-Game Chips by completing in-game tasks, missions, or achievements. These chips can then be used to purchase in-game items, upgrades, cosmetics, or unlock new levels.

2. In-Game Economy: Developers can design complex in-game economies using In-Game Chips. Players can trade or exchange chips with each other to acquire rare items, trade with other players, or participate in player-driven economies within the game.

3. Reward System: In-Game Chips can serve as a reward system for players who engage actively in the game. Developers can distribute chips to players as rewards for reaching milestones, winning competitions, or demonstrating exceptional skills. These rewards can incentivize players to continue playing and achieving in the game.

4. Social Interaction: In-Game Chips can facilitate social interaction among players. Players can gift or trade chips with their friends or engage in friendly competitions where chips are wagered. This fosters a sense of community and engagement within the game.

5. Airdrops and Promotions: In-Game Chips can be airdropped to players' mirror addresses as part of promotional campaigns or as a gesture of appreciation. These airdropped chips can be used to attract new players, retain existing ones, or introduce special events within the game.

6. Limited Edition Collectibles: Developers can create limited edition or rare InGameChips that serve as collectible items within the game. Players can trade or showcase these unique chips, creating a market for collectors and enthusiasts.

FURTHER POSSIBLE USE CASE Cross-Game Utility: In-Game Chips can have utility across multiple games within the ZooGames ecosystem. Players can accumulate chips from different games and use them interchangeably within any compatible game on the platform, enhancing the interconnectedness of the gaming experience.

Init In-Game Chips creation

To create an In-Game Chips token using the ZooGames API, you can follow these steps:

1. Send a request to the API endpoint, specifying the Token name and symbol in the request payload.

2. The API will process your request and generate a new In-Game Chips token with the provided Token name and symbol.

3. Once the token creation is successful, you will receive a response containing the necessary information about the newly created token, such as its contract address and other relevant details.

4. You can now use this In-Game Chips token within your game environment.

Initialize ERC20 before using the token

POST API_END_POINT_URL/API_KEY/erc20/create

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    tokenAddress: '0xe3c4937ee22e1f2eb80d2d7a881e7777',
    createTxHash: '0x12345648945648784564687845647887',
    type:'erc20'
  }
}

{
    success: false;
    errors: [
        {
            message: "any error message",
            data: {
               // Some data properties //
            }
        }
    ];
}

Mint In-Game Chips

This function allows game developers to generate new tokens on-demand, providing flexibility and control over the in-game economy.

Mint Tokens by amount to any ZooGamesID

POST API_END_POINT_URL/API_KEY/erc20/mint

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    mintTxHash: '0x12345678745648789546541324',
    tokenAddress: '0xAb5448754A225F655458Ea52988',
    to: 'ZooGamesID',
    amount: '1000',
  }
}

{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "any error message",
                data: {
                   // Some data properties //
                }
            }
        ];
    }
}

Burn In-Game Chips

This function allows game developers to remove existing tokens from circulation, providing control over the in-game economy and token supply.

Burn Tokens by amount from any ZooGamesID

POST API_END_POINT_URL/API_KEY/erc20/burn

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    burnTxHash: '0x12345678745648789546541324',
    tokenAddress: '0xAb5448754A225F655458Ea52988',
    from: 'ZooGamesID',
    amount: '1000',
  }
}

{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "any error message",
                data: {
                   // Some data properties //
                }
            }
        ];
    }
}

Transfer In-Game Chips

Capability to transfer In-Game Chips tokens from one user (User A) to another user (User B) using the "TRANSFER" function. This function allows for seamless peer-to-peer token transfers within the game ecosystem.

Transfer Tokens by amount to any ZooGamesID

POST API_END_POINT_URL/API_KEY/erc20/transfer

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    transferTxHash: '0x12345678745648789546541324',
    tokenAddress: '0xAb5448754A225F655458Ea52988',
    from: 'ZooGamesIDA',
    to: 'ZooGamesIDB'
    amount: '1000',
  }
}

{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "any error message",
                data: {
                   // Some data properties //
                }
            }
        ];
    }
}

In-Game Chips Balance

Check the token Balance by ZooGamesID

POST API_END_POINT_URL/API_KEY/erc20/balance

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: '1000',
}

{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "any error message",
                data: {
                   // Some data properties //
                }
            }
        ];
    }
}

Ready

You can utilize this API to verify the eligibility of players who wish to join a game while they are in the lobby or waiting room. The API allows you to perform several checks to ensure that each player meets the necessary requirements. These checks include:

1. Validating the vZOO balance of each player: Ensuring that each player has a sufficient balance of vZOO tokens to participate in the game.

2. Checking if a player has been banned from the platform: Verifying if a player has been restricted from accessing the game due to violations or other reasons.

3. Verifying that the cost of joining the game does not exceed the maximum vZOO spending limit set for the game.

4. Grant access to the user if they pass all the validations of the game settlement.

5. Checking if the number of players exceeds the limit set for the game: Ensuring that the number of players attempting to join does not exceed the specified limit.

6. Verifying if the game owner's mirror address has sufficient vZOO balance: This check is useful if the game owner needs to top-up the reward or provide additional funds.

7. Verifying if the game has been verified by Zoo.Games: This check ensures that the game has undergone the necessary verification process by Zoo.Games.

We recommend that the game server performs these checks for each player upon entry. By calling this API with the relevant player information, the game server can determine if a player meets the criteria. If a player fails to pass any of the checks, the game server should reject their entry and remove them from the lobby or waiting room. This process helps maintain the integrity and fairness of the game environment.

Verify all information of players before starting the game

POST API_END_POINT_URL/API_KEY/game/ready

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    roundId: '0xe3c4937ee22e1f2eb80d2d7a881e7777de9aa547006a145f4dd5bb8ec7b40e31'
  }
}

// Error by API //
{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "sub error message #1",
                data: {
                   // requested data//
                }
            },
            {
                message: "sub error message #2",
                data: {
                   // requested data//
                }
            }
        ];
    }
}
// Error by Contract / Reverted by contract //
{
  success: false,
  message: 'Contract Pre-Check Error',
  data: {
    op: '0x95A6010F499005DE33F0DD526ce8f5a36CeA45a3',
    scError: {
        // Reverted reason //
    }
  }
}

import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'
import axios from 'axios';

// Initialized API KEY and SECRET KEY
const API_KEY = 'YourApiKey';
const SEC_KEY = 'YourSecretKey';
const GAME_ADDRESS = '0x8Cf0A877E906DEaD748A41aE9EA8c220E4247D35';
// Signing body data with HMAC signing
let body = {
    userJwts: ['Player#1 JWT', 'Player#2 JWT'], // JWTs by ordered of entry
    userPrimaryAddresses: ['0x682A8B3683292442fACa52e9B6537Fabcd0AE568','0x79CA8B3683292442fACa52e9B6537FE58d0AE576'],
    userLockAmounts: [10,10],
    GAME_ADDRESS,
    gameLockAmount: 10,
  };
let bodyMessage = JSON.stringify(body); 
let hmac = ApiKey.signData(bodyMessage, SEC_KEY); // hmac or SignedSignatureFromPayload  

// Request by Post Method //
let ret = await axios.post(`/api/${API_KEY}/game/ready`, body, {headers:{Authorization: `Bearer ${hmac}`}});
console.log('game ready:', ret.data);

Start

After using the "Ready" API to verify the validity of the game settlement, you can proceed to use the "Start" function to initiate the game round. The Start API allows you to lock the specified amounts from the users and the game developer based on your provided parameters.

Start the game round

POST API_END_POINT_URL/API_KEY/game/start

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    roundId: '0xe3c4937ee22e1f2eb80d2d7a881e7777de9aa547006a145f4dd5bb8ec7b40e31',
    txHash: '0xe259f525616f295e877a0da35b59e45f6c2e48c340a16102eb995f0d0c4c36a1'
  }
}

// Error by API //
{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "sub error message #1",
                data: {
                   // requested data//
                }
            },
            {
                message: "sub error message #2",
                data: {
                   // requested data//
                }
            }
        ];
    }
}
// Error by Contract / Reverted by contract //
{
  success: false,
  message: 'Contract Pre-Check Error',
  data: {
    op: '0x95A6010F499005DE33F0DD526ce8f5a36CeA45a3',
    scError: {
        // Reverted reason //
    }
  }
}

import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'
import axios from 'axios';

// Initialized API KEY and SECRET KEY
const API_KEY = 'YourApiKey';
const SEC_KEY = 'YourSecretKey';
const GAME_ADDRESS = '0x8Cf0A877E906DEaD748A41aE9EA8c220E4247D35';
// Signing body data with HMAC signing
let body = {
    userJwts: ['Player#1 JWT', 'Player#2 JWT'], // JWTs by ordered of entry
    userPrimaryAddresses: ['0x682A8B3683292442fACa52e9B6537Fabcd0AE568','0x79CA8B3683292442fACa52e9B6537FE58d0AE576'],
    userLockAmounts: [10,10],
    GAME_ADDRESS,
    gameLockAmount: 10,
  };
let bodyMessage = JSON.stringify(body); 
let hmac = ApiKey.signData(bodyMessage, SEC_KEY); // hmac or SignedSignatureFromPayload  

// Request by Post Method //
let ret = await axios.post(`/api/${API_KEY}/game/start`, body, {headers:{Authorization: `Bearer ${hmac}`}});
console.log('game ready:', ret.data);

Over

The Over API is used to finalize the game round and broadcast the rewards that each user will receive from the locked vZOO pool of a specific game. The rules for distributing rewards are as follows:

1. The total amount paid by players should not exceed the total locked vZOO in the pool.

2. Assume you have two players with an entry fee of 100 vZOO each, resulting in a locked vZOO pool of 200 vZOO. If the final reward is 190 vZOO for Player A and 10 vZOO for Player B (determined by the game), you need to call the "Game Over" API with adjusted rewards.

3. If the game developer is entitled to receive a fee from the players' rewards, it should be deducted accordingly. This deduction occurs after the platform fee calculation.

4. It's essential to ensure that the total amount paid by players, including the platform fee, does not exceed the locked vZOO pool amount.

5. If the game developer has topped up additional rewards for this round, it is necessary to follow the rule of "Total paid + Platform Fee <= Locked vZOO Pool amount."

By adhering to these rules and providing the adjusted rewards (after deducting the platform fee and game developer's fee, if applicable), the "Game Over" API can be used to distribute the final rewards to the players.

Finalize the game round with broadcast a reward

POST API_END_POINT_URL/API_KEY/game/over

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters

Request Body

{
  success: true,
  data: {
    roundId: '0xe3c4937ee22e1f2eb80d2d7a881e7777de9aa547006a145f4dd5bb8ec7b40e31',
    txHash: '0xe259f525616f295e877a0da35b59e45f6c2e48c340a16102eb995f0d0c4c36a1'
  }
}

// Error by API //
{
    success: false;
    message: 'The primary error message',
    data: {
        errors: [
            {
                message: "sub error message #1",
                data: {
                   // requested data//
                }
            },
            {
                message: "sub error message #2",
                data: {
                   // requested data//
                }
            }
        ];
    }
}
// Error by Contract / Reverted by contract //
{
  success: false,
  message: 'Contract Pre-Check Error',
  data: {
    op: '0x95A6010F499005DE33F0DD526ce8f5a36CeA45a3',
    scError: {
        // Reverted reason //
    }
  }
}

import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'
import axios from 'axios';

// Initialized API KEY and SECRET KEY
const API_KEY = 'YourApiKey';
const SEC_KEY = 'YourSecretKey';
const GAME_ADDRESS = '0x8Cf0A877E906DEaD748A41aE9EA8c220E4247D35';
// Round Id you got from returned value of "Game Start"
const roundId = '0x5a9d48e489bd22ffa627937aec97d2f8e15f0758b3cab9f208f1642450cbb4e6'
// Signing body data with HMAC signing
let body = {
    gameResultAmount: 0,
    usersResultAmount: [17.64, 1.8],
    roundId,
    GAME_ADDRESS ,
  };
let bodyMessage = JSON.stringify(body); 
let hmac = ApiKey.signData(bodyMessage, SEC_KEY); // hmac or SignedSignatureFromPayload  

// Request by Post Method //
let ret = await axios.post(`/api/${API_KEY}/game/over`, body, {headers:{Authorization: `Bearer ${hmac}`}});
console.log('game ready:', ret.data);

Over V2

This is similar to V1, but there’s no need to deduct a fee. You can input the full amount of rewards. The only condition is that the total reward amount must match exactly.

For example, if you startAPI request with 4 players and each player has locked 100 vZOO, then the total locked vZOO is 400 vZOO.

With this Over V2 API, you need to distribute all 400 vZOO to the players. The reward amount cannot be less or more than this. It must be exactly 400 vZOO.

Finalize the game round with broadcast a reward

POST API_END_POINT_URL/API_KEY/game/over_v2

SDK Preparation

You need to prepare for SignedSignatureFromPayload by

Installing zoo-game-sdk by npm install zoo-game-sdk

Import SDK by import * as ApiKey from 'zoo-game-sdk/src/auth/apikey/index'

Signing by SDK

let bodyMessage =JSON.stringify(payload);

let hmac = ApiKey.signData(bodyMessage, SEC_KEY);

*Use "hmac" as SignedSignatureFromPayload

Query Parameters