Follow along on Github here: https://github.com/Made-For-Gamers/game-jam-webgl-template

(1) Get an API key and URL

To use 0xCord's API for Chainlink VRF v2, you'll need an 0xCord API key. You can get these by signing up on the 0xCord website. Once you have your API key and URL, you can use them to send requests to the API.

a. Sign up for an account on 0xCord

To use the 0xCord VRF API, you need to sign up for an account on their website. Go      to https://0xcord.com and follow the sign-up process.

b. Create a new Dapp

Once you've signed up, create a new Dapp by following these steps:

- Click on "Create Dapp" on the 0xCord dashboard.

- Enter a name for your Dapp and click on "Create".

c. Provision Chainlink for your Dapp

After you've created your Dapp, you need to provision Chainlink for it by following      these steps:

- Click on “Add new service”.

- Select “Chainlink VRF V2” from the Infra hub and select the dapp name from the           dropdown.

Once you've provisioned Chainlink for your Dapp, you can get your API key.

d. Get your API key

To get your API key, you can use the "Fetch Config Vars" button on the dapp      page.

- Copy the "API KEY" value.

Your API key is now available to use with the 0xCord VRF API.

(2) Create a script in Unity

Next, create a script in Unity that will send requests to the 0xcord VRF API. The example code we provided above shows how to do this. You can use the UnityWebRequest class to send HTTP requests to the API.

(3) Call the API

To generate a random number using the 0xcord VRF API, you'll need to call the API with your API key and URL. In the example code, the URL is set to "https://0xcord.com/api/vrfv2/requestRandomNumber?network=fuji&numWords=1", which requests a single random number from the "fuji" network.

The authToken variable in the code is used to set the API key. You should replace this value with your own API key.

[SerializeField] private TextMeshProUGUI txtHeading; //text field to display result
[SerializeField] private Button BtnCallApi; //Button that acitons the call
[SerializeField] private string apiKey; // Add your key in the inspector

//Button calls this method
public void CallVRF()
    {
        StartCoroutine(RequestRandomNumber());
    }

    private IEnumerator RequestRandomNumber()
    {
        BtnCallApi.enabled = false;
        txtHeading.text = "Requesting random number from VRF.  Please wait...";

        string url = "https://0xcord.com/api/vrfv2/requestRandomNumber?network=fuji&numWords=1";
        string authToken = apiKey;

        UnityWebRequest request = UnityWebRequest.Post(url, "");

        request.SetRequestHeader("Authorization", authToken);
        yield return request.SendWebRequest();

        // ....
}

An example can be found here: https://github.com/Made-For-Gamers/game-jam-webgl-template/blob/f0ad0f224d8bd0f48868aab0f0d77b3f22a43b5b/Assets/Scripts/0xcord/Chainlink_API.cs

(4) Parse the response

Once you've sent the request to the API, you'll need to parse the response. In the example code, the response is returned as a JSON string. You can use the JsonUtility class to parse the JSON into a C# object.

Create another script class for the returned JSON structure:

using System;

[Serializable]
public class RandomNumberResponse 
{   
     public Data data;

    [Serializable]
    public class Data
    {
        public bool success;
        public string requestId;
        public string transactionHash;
        public string url;
        public string[] randomNumber;
    }
}

An example can be found here: https://github.com/Made-For-Gamers/game-jam-webgl-template/blob/f0ad0f224d8bd0f48868aab0f0d77b3f22a43b5b/Assets/Scripts/0xcord/Return Data/RandomNumberResponse.cs

Add the following inside the RequestRandomNumber method:

//...

if (request.result == UnityWebRequest.Result.Success)
        {
            string json = request.downloadHandler.text;
            RandomNumberResponse response = JsonConvert.DeserializeObject<RandomNumberResponse>(json);

            if (response != null && response != null && response.data.randomNumber != null && response.data.randomNumber.Length > 0)
            {
                string randomNumber = response.data.randomNumber[0];
                txtHeading.text = "Random number: " + randomNumber;

                Debug.Log("requestId: " + response.data.requestId);
                Debug.Log("transactionHash: " + response.data.transactionHash);
                Debug.Log("url: " + response.data.url);
                Debug.Log("randomNumber: " + randomNumber);
            }
            else
            {
                Debug.Log("Failed to parse response");
            }
        }
        else
        {
            Debug.Log("Error: " + request.error);
        }
        BtnCallApi.enabled = true;

(5) Use the random number in your game

Finally, you can use the random number generated by the 0xCord VRF API in your game. In the example code, the random number is displayed in the Unity UI, using the ChangeText method. You can use the random number in any way you need to in your game. You can also use the transaction hash and URL, and show this information to your players.

In conclusion, integrating 0xCord's VRF API into your Unity game is a straightforward process. By following the steps outlined above, you can easily generate verifiably random numbers for your game. The 0xCord API is built on top of the Chainlink VRF infrastructure, which ensures the randomness of the generated numbers, making it a reliable solution for various use cases, including gaming, gambling, and security applications.

Thanks!

How 0xCord Enables Users To Easily Access Chainlink VRF 0xCord provides developers with an integration solution that enables them to seamlessly access hyper-reliable, secure, and decentralized Web3 services such as Chainlink VRF. With 0xCord, now web3 developers, enterprises, and Web2-native applications can build on Web3 technology without the headaches of acquiring and custody cryptocurrency or developing custom integrations. Instead, they can access Web3 services, like Chainlink VRF, through the 0xCord API and pay for them via credit card. Already, the Web3 ecosystem has seen a wide array of innovative NFT projects from enterprises, such as the NBA using Chainlink VRF to power its NFT collection. This partnership will help expand the VRF user base, make it easier to integrate, and position developers to discover new VRF use cases.

Partnership Details 0xCord will support the Chainlink ecosystem, helping to drive Web3 infrastructure adoption by enterprises. To be more specific, 0xCord will support Chainlink Labs by assisting enterprises in integrating key Chainlink services, such as Chainlink VRF. By working with industry leaders like Chainlink Labs, 0xCord will continue to develop its Web3 integrations platform and become an important link between enterprises and the Web3 ecosystem.

About Chainlink Labs Chainlink Labs is the leading provider of secure and reliable open-source blockchain oracle solutions, enhancing smart contracts by connecting them to a wide range of off-chain data sources and computations, such as asset prices, web APIs, IoT devices, payment systems, and more. Chainlink Labs is dedicated to the development and integration of Chainlink as the standard decentralized oracle framework used by smart contracts across any blockchain.

About Chainlink Chainlink is the industry-standard Web3 services platform that has enabled trillions of dollars in transaction volume across DeFi, insurance, gaming, NFTs, and other major industries. As the leading decentralized oracle network, Chainlink enables developers to build feature-rich Web3 applications with seamless access to real-world data and off-chain computation across any blockchain and provides global enterprises with a universal gateway to all blockchains.

The Chainlink ecosystem features over 1,500 projects that use decentralized oracle networks to seamlessly access services such as decentralized data feeds, a verifiably random number generator, a proven smart contract automation solution, and reliable asset reserve verification. In addition, Chainlink can bridge the gap for Web2 companies trying to enter the Web3 space by offering projects and data providers a universal gateway to all blockchains.

About 0xCord 0xCord, an infrastructure hub for web3.

To build a web3 application, it is really difficult to ACCESS web3 infrastructure.

Currently, web3 infrastructure is paid for in unique cryptocurrencies, fragmented, and VERY complex to set up.

Developers 🤝 Infrastructure

For web3 developers: 0xCord is the easiest way to ACCESS web3 infrastructure via native payments, composability, and configuration, all in one unified place.

For web3 infrastructure: 0xCord is a “Front-End as a Service”.

• Reduces churn.

• Expands TAM.

• Provides a new distribution channel in the 0xCord hub.

• Increases revenue.

With the accelerating boom of web3 developers and infrastructure, building a blockchain application is increasingly becoming more difficult, unless the issue of infrastructure ACCESS is solved.

Learn more at 0xCord.com

1. To get started, head over to 0xCord.com and sign up to create your account. Once you've submitted your info, we'll send you a magic link via email. Just click on it and voila - you'll be taken straight to your dashboard!

2. Once you're logged in, you'll see your dashboard which displays all of your dapps, including NFTs, DeFi products, and DAOs - basically anything that requires Web3 infrastructure. To get started, you'll want to create a new dapp. Just hit the "Create new" button and give it a name.

3. Now that you've created your dapp, let's take a look at its page by clicking "view details". As you'll see, there isn't any Web3 infrastructure set up yet. That's where the Infra Hub comes in - this is where you can provision the resources you need. Our first piece of infra is Chainlink VRF V2. Simply select your dapp from the dropdown, and we'll automatically provision Chainlink VRF V2 for you. Best of all, it supports both on-chain and off-chain consumption for all blockchains that Chainlink supports. As of 2/28, we have several testnets available for you to use for free, including Polygon Mumbai, Sepolia, Fuji, BSC testnet, Klaytn testnet, Fantom testnet, and Goerli.

Onchain API

Usually, using Chainlink VRF V2 onchain requires several steps, such as acquiring gas tokens, $LINK tokens, creating subscriptions, and managing subscription balances. But with 0xCord, we simplify the process by provisioning and managing the subscriptions for you - no crypto required! Here's how to use Chainlink VRF V2 onchain with 0xCord:

1. Click "Fetch Config Vars" to view the fully-funded subscriptions that are ready to use.

2. Copy the subscription ID for the chain you'll deploy your contract to. For example, on Polygon Mumbai this might be 2894.

   1. If you’re following the Chainlink VRF tutorial , use our subscription ID in this step:

   2. Configure your deployment. On the Deploy tab in Remix, select the Injected Provider environment, select the VRFv2Consumer contract from the contract list, and specify your subscriptionId so the constructor can set it.

3. Once your contract is deployed, copy its address. The next step is to link the consumer to the subscription, which you can do in one of two ways:

   1. Using the 0xCord app, click the gears icon on the Chainlink instance to open the ChainLink Subscription Consumers modal. Enter the contract address, select the chain from the dropdown, and click save. This will create a transaction linking the consumer to the chain.

   2. Alternatively, you can programmatically link the consumer to the subscription and use our API’s Add Consumer endpoint. First go to the dapp page on 0xCord, and copy the dappId from the URL params. Then, authenticate using the API key, and pass in the network, consumer, and dappId as query params.

      1. Example request:

         curl --location --request POST 'https://0xcord.com/api/vrfv2/addConsumer?dappId=1&network=polygon_mumbai&consumer=0x53470b76D3f57E6C7be40BB333014481ec1c5530' \
         --header 'Authorization: xxxx' 
         

And that's it! With 0xCord, you can now easily use Chainlink VRF in your contract without worrying about managing subscriptions.

Offchain API

With 0xCord's offchain API, you can easily consume VRF V2 through a simple RESTful JSON API call, bridging the gap between web2 and decentralized web3 infrastructure. Here's how to use it:

1. Copy the API key from the "Fetch Config Vars" section, which is used to access the 0xCord RESTful JSON API. Docs can be found here.

2. In Postman, select the production environment and paste the API key into the "apiKey" variable.

3. Hit the "Request Random Number" API call, selecting the desired network (polygon_mumbai, sepolia, fuji, bsc_testnet, klaytn_testnet, fantom_testnet, goerli) and specifying the number of random numbers with the "numWords" parameter (1 to 500).

   1. Example request:

      curl --location --request POST 'https://0xcord.com/api/vrfv2/requestRandomNumber/?network=polygon_mumbai&numWords=1' \
      --header 'Authorization: xxx'
      

   2. Example response:

      {
          "data": {
              "success": true,
              "requestId": "82772297461836742329238512432706064630856291450561249462036537828944094389038",
              "transactionHash": "0x1f636827ba3572472e117f8f008b3fc6726c1284c0ceca586e3a0e676f0406eb",
              "url": "https://mumbai.polygonscan.com/tx/0x1f636827ba3572472e117f8f008b3fc6726c1284c0ceca586e3a0e676f0406eb"
          }
      }
      

   3. This will return a Chainlink request ID as well as a link to etherscan.

4. Retrieve the random numbers using the "Get Random Numbers" endpoint, specifying the same network and request ID.

   1. Example request:

      curl --location 'https://0xcord.com/api/vrfv2/getRandomNumber/?network=polygon_mumbai&requestId=82772297461836742329238512432706064630856291450561249462036537828944094389038' \
      --header 'Authorization: xxx'
      

   2. Example response:

      {
          "data": {
              "fulfilled": true,
              "randomNumber": [
      "111296169371105942025256963044261804772682237016873883880854565109176540425880", "48853847565293424268317777741688717343601339637655607855994234898572199201663",
      "22503081880076003702041350408548819131186130333868717438739033661493489536203",
      "78662195269794346569705780123769753316601136453919903121333806175221242048442",
      "26015862336455109621425908291815156389231643676531347218138706099532711105913"
              ]
          }
      }
      

   3. That's it! The returned random numbers are provably verifiable on-chain and ready to use in your application.

In this tutorial, we've shown you how to use 0xCord's Chainlink VRF V2 API to generate random numbers for your Web3 application. With 0xCord, you can easily provision subscriptions and start consuming VRF V2 without having to worry about managing subscriptions and monitoring balances.

Whether you prefer onchain or offchain consumption, 0xCord has you covered. By using our offchain API, you can make simple RESTful JSON API calls to start consuming VRF V2.

We hope you found this tutorial helpful and that it gets you one step closer to building your Web3 application. If you have any questions or feedback, feel free to reach out to us at contact@0xcord.com. Happy coding!