question

I have written an answer on Sep 09 2023 but now I realized that that answer had 2 problems.

1. The bought item does not appear on PlayFab inventory.

2. Xsolla always assume that the buyer is from US.

After contacting Xsolla and after some trial and error, this is the solution that worked:

• Set up server OAuth 2.0 client as explained here: https://developers.xsolla.com/sdk/baas-templates/use-store-with-baas-auth/#baas_templates_set_up_server_oauth

• In the same Login project, set the Storage as PlayFab storage as explained in the steps here: https://developers.xsolla.com/doc/login/integration-guide/connect-users-storage/#login_guide_connect_users_storage_playfab

• Enable inventory synchronization as explained here: https://developers.xsolla.com/doc/in-game-store/extensions/playfab-integration/#in_game_store_playfab_integration_add_items_to_inventory

• Add this code to Unity:

public static void RealMoneyPurchase(string itemId, Action<Dictionary<string, object>> successCallback = null, Action<PlayFabError> failureCallback = null)
    {
        // First, run a CloudScript function called CreateXsollaRequest
        var createXsollaRequest = new ExecuteCloudScriptRequest{
        FunctionName = "CreateXsollaRequest",
        FunctionParameter = new { itemId = itemId, sandbox = sandbox }, // sandbox is a boolean that determines whether to use the sandbox or production Xsolla environment
        };

        PlayFabClientAPI.ExecuteCloudScript(
        createXsollaRequest,
        success =>
        {
            
            var json = JsonConvert.DeserializeObject<Dictionary<string, object>>(success.ToJson());
            Debug.Log($"CreateXsollaRequest success: {success.ToJson()}");
            var functionResult = JsonConvert.DeserializeObject<Dictionary<string, object>>(JsonConvert.SerializeObject(json["FunctionResult"]));
            if (functionResult.ContainsKey("error"))
            {
                Debug.LogError($"CreateXsollaRequest error: {functionResult["error"]}");
                if (failureCallback != null)
                {
                    failureCallback(new PlayFabError() { ErrorMessage = functionResult["error"].ToString() });
                }
                return;
            }

            // Second, use the returned uri, headers, and body to make a POST request to Xsolla
            var uri = functionResult["uri"].ToString();
            var headers = JsonConvert.DeserializeObject<Dictionary<string, object>>(functionResult["headers"].ToString());
            var body = functionResult["body"].ToString();
            string response = Requests.PostRequest(uri, headers, body);
            Debug.Log($"GetXsollaPaymentToken response: {response}");
            var responseJson = JsonConvert.DeserializeObject<Dictionary<string, object>>(response);
            if (responseJson.ContainsKey("error"))
            {
                Debug.LogError($"GetXsollaPaymentToken error: {responseJson["error"]}");
                if (failureCallback != null)
                {
                    failureCallback(new PlayFabError() { ErrorMessage = responseJson["error"].ToString() });
                }
                return;
            }

            // Third, use the returned token to open the Xsolla payment UI
            var token = responseJson["token"].ToString();
            var orderId = responseJson["order_id"].ToString();
            var url = "https://secure.xsolla.com/paystation4/?token=" + token;
            if (sandbox)
            {
                url = "https://sandbox-secure.xsolla.com/paystation4/?token=" + token;
            }
            Application.OpenURL(url);
            if (successCallback != null)
            {
                successCallback(functionResult);
            }
        },
        playfabError => {
            Debug.LogError($"GetXsollaAccessToken error: {playfabError.ErrorMessage}");
            if (failureCallback != null)
            {
                failureCallback(playfabError);
            }
    });
    }

• The Requests.PostRequest function in the previous code is from this C# script:

using UnityEngine.Networking;
using UnityEngine;
using System.Collections;
using System;
using System.Collections.Generic;
using System.Net;
using System.IO;
using Newtonsoft.Json.Linq;

public class Requests
{

    public static string PostRequest(string uri, Dictionary<string, object> headers, string body)
    {
        var httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
        httpWebRequest.ContentType = "application/json";
        httpWebRequest.Method = "POST";
        foreach (var header in headers)
        {
            httpWebRequest.Headers.Add(header.Key, header.Value.ToString());
        }

        using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
        {
            streamWriter.Write(body);
        }

        var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
        using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
        {
            var result = streamReader.ReadToEnd();
            return result;
        }
    }
}

• Add this code to CloudScript (make sure to fill the input parameters):

handlers.CreateXsollaRequest = function (args) {
    
    // The purpose of this CloudScript function is to create a uri, header,
    // and body that the client will then use to make an http request.
    
    ////// INPUT PARAMTERS //////
    
    // TODO replace with production credentials
    const projectId = // Include your Xsolla project ID here
    const apikey = // Include your Xsolla API key here
    const loginProjectId = // Include your Xsolla Login Project ID here
    const serverOauthClientId = // Include the Client ID of the server oauth client you set in step 1
    const serverOauthClientSecret =// Include the Client secret of the server oauth client you set in step 1
    
    ////// END OF INPUT PARAMTERS //////
    
    // Get server token
    const getServerTokenBody =
        "grant_type=client_credentials" +
        `&client_secret=${serverOauthClientSecret}` +
        `&client_id=${serverOauthClientId}`;

    const serverTokenResponse = JSON.parse(
        http.request(
            "https://login.xsolla.com/api/oauth2/token",
            "post",
            getServerTokenBody,
            "application/x-www-form-urlencoded",
            {})
    );

    let serverToken = ""
    if ('access_token' in serverTokenResponse) {
        serverToken = serverTokenResponse.access_token;
    } else {
        return {
            "error_message": "Server token not received"
        }
    }
    
    // Get user token
    const getUserTokenHeaders = {
        "X-Server-Authorization": serverToken
    }

    const getUserTokenBody = JSON.stringify(
        {
            "server_custom_id": currentPlayerId,
        }
    );

    const getUserTokenPath =
        "/api/users/login/server_custom_id?" +
        `projectId=${loginProjectId}&` +
        `publisher_project_id=${projectId}`;

    const userTokenResponse = JSON.parse(
        http.request(
            "https://login.xsolla.com" + getUserTokenPath,
            "post",
            getUserTokenBody,
            "application/json",
            getUserTokenHeaders)
    );
    
    let userToken = ""
    if ('token' in userTokenResponse) {
        userToken = userTokenResponse.token
        
        // Create a uri, header, and body and pass them to the client.
        const uri = `https://store.xsolla.com/api/v2/project/${projectId}/payment/item/${args.itemId}`
        const headers = JSON.stringify(
            {
                "Authorization": `Bearer ${userToken}`
            }    
        )
        const body = JSON.stringify(
            {
                "quantity": 1,
                "sandbox": args.sandbox,
                "locale": "en"
            }    
        )
        
        return {"uri": uri, "headers": headers, "body": body}
    } else {
        return {
            "error_message": "User token not received"
        }
    }
    
    
    
}

The cloudscript function will create a user token, then it will pass the parameters needed to create an http request to the unity game. The unity game will then use these parameters to get the payment token and open the payment UI.