Push changes

src/Prospect.Server.Api/Services/CloudScript/CloudScriptService.cs

@@ -32,7 +32,10 @@ public class CloudScriptService
         using (var scope = _serviceScopeFactory.CreateScope())
         {
             var functionClazz = ActivatorUtilities.CreateInstance(scope.ServiceProvider, function.Clazz);
-            var functionParam = JsonSerializer.Deserialize(parameter, function.RequestType);
+            // Some functions have empty parameters which result in malformed JSON.
+            var parameterJson = parameter == "" ? "{}" : parameter;
+            // _logger.LogInformation("Received parameter: {Param}", parameterJson);
+            var functionParam = JsonSerializer.Deserialize(parameterJson, function.RequestType);
             if (functionParam == null)
             {
                 _logger.LogWarning("Function {Function} deserialization returned null", name);
@@ -40,9 +43,9 @@ public class CloudScriptService
             }
 
             var functionTask = function.Delegate(functionClazz, functionParam);
-            
+
             await functionTask;
-            
+
             return (object)((dynamic)functionTask).Result;
         }
     }

src/Prospect.Server.Api/Services/CloudScript/Functions/ActivateContract.cs

@@ -0,0 +1,94 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYActivateContractRequest {
+    [JsonPropertyName("contractId")]
+    public string ContractID { get; set; }
+}
+
+public class FYActivateContractResult {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+    [JsonPropertyName("changedCurrencties")]
+    public object[] ChangedCurrencties { get; set; }
+    [JsonPropertyName("activatedContract")]
+    public FYActiveContractPlayerData ActivatedContract { get; set; }
+    [JsonPropertyName("status")]
+    public int Status { get; set; }
+}
+
+public class FYGetActiveContractsResult {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+    [JsonPropertyName("contracts")]
+    public List<FYActiveContractPlayerData> Contracts { get; set; }
+}
+
+[CloudScriptFunction("ActivateContract")]
+public class ActivateContract : ICloudScriptFunction<FYActivateContractRequest, FYActivateContractResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public ActivateContract(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYActivateContractResult> ExecuteAsync(FYActivateContractRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"ContractsActive"});
+        var titleData = _titleDataService.Find(new List<string>{"Contracts"});
+
+        var contracts = JsonSerializer.Deserialize<Dictionary<string, TitleDataContractInfo>>(titleData["Contracts"]);
+        var contract = contracts[request.ContractID];
+        if (contract == null) {
+            return new FYActivateContractResult
+            {
+                UserID = userId,
+                Error = "Contract not found",
+                Status = 3 // EYActivateContractRequestStatus::FAILED_GETTING_STATIC_DATA
+            };
+        }
+        // TODO: Contract unlock criteria
+
+        var progress = new int[contract.Objectives.Length];
+        var contractsActive = JsonSerializer.Deserialize<FYGetActiveContractsResult>(userData["ContractsActive"].Value);
+        var contractData = new FYActiveContractPlayerData {
+            ContractID = request.ContractID,
+            Progress = progress,
+        };
+        contractsActive.Contracts.Add(contractData);
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{ ["ContractsActive"] = JsonSerializer.Serialize(contractsActive) }
+        );
+
+        return new FYActivateContractResult
+        {
+            UserID = userId,
+            Error = "",
+            ChangedCurrencties = [], // NOTE: There are no paid contracts in Frontier.
+            ActivatedContract = contractData,
+            Status = 14 // EYActivateContractRequestStatus::OK
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/CanGoToStationRequest.cs

@@ -0,0 +1,43 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class CanGoToStationRequestRequest
+{
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+    [JsonPropertyName("region")]
+    public string Region { get; set; }
+}
+
+public class CanGoToStationRequestResponse
+{
+    [JsonPropertyName("canGoToStation")]
+    public bool CanGoToStation { get; set; }
+    [JsonPropertyName("delta")]
+    public int Delta { get; set; }
+    [JsonPropertyName("timeStampUpdate")]
+    public int TimeStampUpdate { get; set; }
+}
+
+[CloudScriptFunction("CanGoToStationRequest")]
+public class CanGoToStationRequestFunction : ICloudScriptFunction<CanGoToStationRequestRequest, CanGoToStationRequestResponse>
+{
+    private readonly ILogger<CanGoToStationRequestFunction> _logger;
+
+    public CanGoToStationRequestFunction(ILogger<CanGoToStationRequestFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<CanGoToStationRequestResponse> ExecuteAsync(CanGoToStationRequestRequest request)
+    {
+        return new CanGoToStationRequestResponse
+        {
+            CanGoToStation = true,
+            Delta = 0,
+            TimeStampUpdate = 0,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/CancelActiveContract.cs

@@ -0,0 +1,65 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYCancelActiveContractRequest {
+    [JsonPropertyName("contractId")]
+    public string ContractID { get; set; }
+}
+
+public class FYCancelActiveContractResult {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+    [JsonPropertyName("contractId")]
+    public string ContractID { get; set; }
+}
+
+[CloudScriptFunction("CancelActiveContract")]
+public class CancelActiveContract : ICloudScriptFunction<FYCancelActiveContractRequest, FYCancelActiveContractResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public CancelActiveContract(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<FYCancelActiveContractResult> ExecuteAsync(FYCancelActiveContractRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"ContractsActive"});
+        var contractsActive = JsonSerializer.Deserialize<FYGetActiveContractsResult>(userData["ContractsActive"].Value);
+        var contractActiveIdx = contractsActive.Contracts.FindIndex(item => item.ContractID == request.ContractID);
+        if (contractActiveIdx == -1) {
+            return new FYCancelActiveContractResult
+            {
+                UserID = userId,
+                Error = "Failed to find active contract",
+            };
+        }
+        contractsActive.Contracts.RemoveAt(contractActiveIdx);
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{ ["ContractsActive"] = JsonSerializer.Serialize(contractsActive) }
+        );
+
+        return new FYCancelActiveContractResult
+        {
+            UserID = userId,
+            Error = "",
+            ContractID = request.ContractID,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/CheckAndPerformUserRollbackIfNeeded.cs

@@ -0,0 +1,37 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class CheckAndPerformUserRollbackIfNeededRequest
+{
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+}
+
+public class CheckAndPerformUserRollbackIfNeededResponse
+{
+    [JsonPropertyName("result")]
+    public int Result { get; set; }
+}
+
+[CloudScriptFunction("CheckAndPerformUserRollbackIfNeeded")]
+public class CheckAndPerformUserRollbackIfNeededFunction : ICloudScriptFunction<CheckAndPerformUserRollbackIfNeededRequest, CheckAndPerformUserRollbackIfNeededResponse>
+{
+    private readonly ILogger<CheckAndPerformUserRollbackIfNeededFunction> _logger;
+
+    public CheckAndPerformUserRollbackIfNeededFunction(ILogger<CheckAndPerformUserRollbackIfNeededFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<CheckAndPerformUserRollbackIfNeededResponse> ExecuteAsync(CheckAndPerformUserRollbackIfNeededRequest request)
+    {
+        _logger.LogInformation("Processing user rollback if needed");
+
+        return new CheckAndPerformUserRollbackIfNeededResponse
+        {
+            Result = 1,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/CheckAndWipeDataForCurrentSeason.cs

@@ -0,0 +1,37 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class CheckAndWipeDataForCurrentSeasonRequest
+{
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+}
+
+public class CheckAndWipeDataForCurrentSeasonResponse
+{
+    [JsonPropertyName("result")]
+    public int Result { get; set; }
+}
+
+[CloudScriptFunction("CheckAndWipeDataForCurrentSeason")]
+public class CheckAndWipeDataForCurrentSeasonFunction : ICloudScriptFunction<CheckAndWipeDataForCurrentSeasonRequest, CheckAndWipeDataForCurrentSeasonResponse>
+{
+    private readonly ILogger<CheckAndWipeDataForCurrentSeasonFunction> _logger;
+
+    public CheckAndWipeDataForCurrentSeasonFunction(ILogger<CheckAndWipeDataForCurrentSeasonFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<CheckAndWipeDataForCurrentSeasonResponse> ExecuteAsync(CheckAndWipeDataForCurrentSeasonRequest request)
+    {
+        _logger.LogInformation("Processing check data wipe for current season");
+
+        return new CheckAndWipeDataForCurrentSeasonResponse
+        {
+            Result = 1,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/CheckClientVersionUpToDate.cs

@@ -0,0 +1,49 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class CheckClientVersionUpToDateRequest
+{
+    [JsonPropertyName("version")]
+    public string Version { get; set; }
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+}
+
+public class CheckClientVersionUpToDateResponse
+{
+    [JsonPropertyName("isClientUpToDate")]
+    public bool IsClientUpToDate { get; set; }
+}
+
+[CloudScriptFunction("CheckClientVersionUpToDate")]
+public class CheckClientVersionUpToDateFunction : ICloudScriptFunction<CheckClientVersionUpToDateRequest, CheckClientVersionUpToDateResponse>
+{
+    private readonly ILogger<CheckClientVersionUpToDateFunction> _logger;
+
+    public CheckClientVersionUpToDateFunction(ILogger<CheckClientVersionUpToDateFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<CheckClientVersionUpToDateResponse> ExecuteAsync(CheckClientVersionUpToDateRequest request)
+    {
+        _logger.LogInformation("Processing client version check request for client {Version}",
+            request.Version);
+
+        // TODO: Validate login
+        // if (string.IsNullOrEmpty(request.LoginNonce))
+        // {
+        //     return new CheckClientVersionUpToDateResponse
+        //     {
+        //         IsClientUpToDate = false,
+        //     };
+        // }
+
+        return new CheckClientVersionUpToDateResponse
+        {
+            IsClientUpToDate = true,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/ClaimActiveContract.cs

@@ -0,0 +1,249 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYClaimCompletedActiveContractRewardsRequest {
+    [JsonPropertyName("contractId")]
+	public string ContractID { get; set; }
+    [JsonPropertyName("contractsToUnlock")]
+	public string[] ContractsToUnlock { get; set; }
+}
+
+public class FYClaimCompletedActiveContractRewardsResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("claimedContractId")]
+	public string ClaimedContractID { get; set; }
+    [JsonPropertyName("newContractIdOnBoard")]
+	public string NewContractIdOnBoard { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("itemsGranted")]
+	public List<FYCustomItemInfo> ItemsGranted { get; set; }
+    [JsonPropertyName("itemsUpdatedOrRemoved")]
+	public List<FYCustomItemInfo> ItemsUpdatedOrRemoved { get; set; }
+    [JsonPropertyName("playerFactionProgressData")]
+	public FYPlayerFactionProgressData PlayerFactionProgressData { get; set; }
+    [JsonPropertyName("contractsActivated")]
+	public List<FYActiveContractPlayerData> ContractsActivated { get; set; }
+    [JsonPropertyName("status")]
+	public int Status { get; set; } // EYClaimContractRewardsStatus
+    [JsonPropertyName("updatedSeasonXp")]
+	public int UpdatedSeasonXp { get; set; }
+}
+
+public class FYGetCompletedContractsResult {
+    [JsonPropertyName("contractsIds")]
+	public List<string> ContractsIDs { get; set; }
+};
+
+[CloudScriptFunction("ClaimActiveContract")]
+public class ClaimActiveContract : ICloudScriptFunction<FYClaimCompletedActiveContractRewardsRequest, FYClaimCompletedActiveContractRewardsResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public ClaimActiveContract(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYClaimCompletedActiveContractRewardsResult> ExecuteAsync(FYClaimCompletedActiveContractRewardsRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var titleData = _titleDataService.Find(new List<string>{"Contracts", "Blueprints"});
+
+        var contracts = JsonSerializer.Deserialize<Dictionary<string, TitleDataContractInfo>>(titleData["Contracts"]);
+        var contract = contracts[request.ContractID];
+        if (contract == null) {
+            return new FYClaimCompletedActiveContractRewardsResult
+            {
+                UserID = userId,
+                Error = "Contract not found",
+                Status = 13, // EYClaimContractRewardsStatus::WRONG_CONTRACT_ID
+            };
+        }
+
+        var factionKey = "FactionProgression" + contract.Faction;
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"ContractsActive", "ContractsOneTimeCompleted", "Balance", "Inventory", factionKey}
+        );
+
+        var factionProgression = JsonSerializer.Deserialize<int>(userData[factionKey].Value);
+        var contractsActive = JsonSerializer.Deserialize<FYGetActiveContractsResult>(userData["ContractsActive"].Value);
+        var contractsCompleted = JsonSerializer.Deserialize<FYGetCompletedContractsResult>(userData["ContractsOneTimeCompleted"].Value);
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+
+        var targetContractIdx = contractsActive.Contracts.FindIndex(item => item.ContractID == request.ContractID);
+        if (targetContractIdx == -1) {
+            return new FYClaimCompletedActiveContractRewardsResult
+            {
+                UserID = userId,
+                Error = "Contract not active",
+                Status = 8, // EYClaimContractRewardsStatus::NO_ACTIVE_CONTRACT
+            };
+        }
+
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+
+        List<FYCustomItemInfo> itemsUpdatedOrRemoved = [];
+        HashSet<string> deletedItemsIds = [];
+        // TODO: Proper progress verification of all objectives
+        foreach (var objective in contract.Objectives) {
+            int remaining = objective.MaxProgress;
+            if (objective.Type == 2) {
+                for (var i = 0; i < inventory.Count; i++) {
+                    var item = inventory[i];
+                    if (item.BaseItemId != objective.ItemToOwn) {
+                        continue;
+                    }
+                    var localRemaining = remaining;
+                    remaining -= item.Amount;
+                    item.Amount -= localRemaining;
+                    if (item.Amount <= 0) {
+                        item.Amount = 0;
+                        deletedItemsIds.Add(item.ItemId);
+                    }
+                    itemsUpdatedOrRemoved.Add(item);
+                    if (remaining <= 0) {
+                        break;
+                    }
+                }
+            }
+            if (remaining > 0) {
+                return new FYClaimCompletedActiveContractRewardsResult
+                {
+                    UserID = userId,
+                    Error = "Objective not met",
+                    Status = 16, // EYClaimContractRewardsStatus::PROGRESS_MISSING
+                };
+            }
+        }
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!deletedItemsIds.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        List<FYCustomItemInfo> itemsGranted = new List<FYCustomItemInfo>();
+        List<FYCurrencyItem> changedCurrencies = [];
+        foreach (var reward in contract.Rewards) {
+            if (reward.ItemID == "SoftCurrency") {
+                balance["SC"] += reward.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] });
+            } else if (reward.ItemID == "Aurum") {
+                balance["AU"] += reward.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] });
+            } else if (reward.ItemID == "InsuranceToken") {
+                balance["IN"] += reward.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "InsuranceToken", Amount = balance["IN"] });
+            } else {
+                var blueprintData = blueprints[reward.ItemID];
+                var remainingAmount = reward.Amount * blueprintData.AmountPerPurchase;
+
+                // Populate incomplete stacks first
+                foreach (var item in newInventory) {
+                    if (item.BaseItemId != reward.ItemID || item.Amount >= blueprintData.MaxAmountPerStack) {
+                        continue;
+                    }
+                    var remainingSpace = blueprintData.MaxAmountPerStack - item.Amount;
+                    var amountToAdd = Math.Min(remainingAmount, remainingSpace);
+                    item.Amount += amountToAdd;
+                    remainingAmount -= amountToAdd;
+                    itemsUpdatedOrRemoved.Add(item);
+                    if (remainingAmount == 0) {
+                        break;
+                    }
+                }
+
+                while (remainingAmount > 0) {
+                    var itemStackAmount = Math.Min(blueprintData.MaxAmountPerStack, remainingAmount);
+                    var itemInfo = new FYCustomItemInfo{
+                        ItemId = Guid.NewGuid().ToString(),
+                        Amount = itemStackAmount,
+                        BaseItemId = reward.ItemID,
+                        Durability = blueprintData.DurabilityMax,
+                        Insurance = "",
+                        InsuranceOwnerPlayfabId = "",
+                        ModData = new FYModItems { M = [] },
+                        Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                        InsuredAttachmentId = "",
+                        PrimaryVanityId = 0,
+                        SecondaryVanityId = 0,
+                        RolledPerks = [],
+                    };
+                    newInventory.Add(itemInfo);
+                    itemsGranted.Add(itemInfo);
+                    remainingAmount -= itemStackAmount;
+                }
+            }
+        }
+
+        factionProgression += contract.ReputationIncrease;
+        contractsActive.Contracts.RemoveAt(targetContractIdx);
+        // Main contracts can be completed only once.
+        if (contract.IsMainContract) {
+            contractsCompleted.ContractsIDs.Add(request.ContractID);
+        }
+
+        var newContracts = new List<FYActiveContractPlayerData>();
+        foreach (var contractIdToUnlock in request.ContractsToUnlock) {
+            var contractToUnlock = contracts[contractIdToUnlock];
+            var progress = new int[contractToUnlock.Objectives.Length];
+            var newContract = new FYActiveContractPlayerData {
+                ContractID = contractIdToUnlock,
+                Progress = progress,
+            };
+            contractsActive.Contracts.Add(newContract);
+            newContracts.Add(newContract);
+        }
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["ContractsOneTimeCompleted"] = JsonSerializer.Serialize(contractsCompleted),
+                ["ContractsActive"] = JsonSerializer.Serialize(contractsActive),
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["Inventory"] = JsonSerializer.Serialize(newInventory),
+                [factionKey] = JsonSerializer.Serialize(factionProgression),
+            }
+        );
+
+        return new FYClaimCompletedActiveContractRewardsResult
+        {
+            UserID = userId,
+            Error = "",
+            ClaimedContractID = request.ContractID,
+            ContractsActivated = newContracts,
+            ItemsUpdatedOrRemoved = itemsUpdatedOrRemoved,
+            ChangedCurrencies = changedCurrencies.ToArray(),
+            ItemsGranted = itemsGranted,
+            NewContractIdOnBoard = "", // TODO: This should be a replacement contract apparently?
+            PlayerFactionProgressData = new FYPlayerFactionProgressData {
+                FactionID = contract.Faction,
+                CurrentProgression = factionProgression,
+            },
+            Status = 18, // EYClaimContractRewardsStatus::OK
+            UpdatedSeasonXp = 0 // TODO: Probably a separate season XP rate configured by server?
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/ClaimGeneratorIncomeClient.cs

@@ -0,0 +1,246 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYClaimGeneratorIncomeClientResult {
+    [JsonPropertyName("userId")]
+	public string UserId { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("generatorId")]
+	public string GeneratorID { get; set; }
+    [JsonPropertyName("changedCurrenciesBalances")]
+	public FYCurrencyItem[] ChangedCurrenciesBalances { get; set; }
+    [JsonPropertyName("grantedItems")]
+	public List<FYCustomItemInfo> GrantedItems { get; set; }
+    [JsonPropertyName("lastClaimTime")]
+	public FYTimestamp LastClaimTime { get; set; }
+};
+
+public class FYClaimGeneratorIncomeClientRequest {
+    [JsonPropertyName("generatorId")]
+	public string GeneratorID { get; set; }
+};
+
+public class FYPassiveGenerator {
+    [JsonPropertyName("generatorId")]
+    public string GeneratorID { get; set; }
+    [JsonPropertyName("lastClaimTime")]
+	public FYTimestamp LastClaimTime { get; set; }
+}
+
+[CloudScriptFunction("ClaimGeneratorIncomeClient")]
+public class ClaimGeneratorIncomeClient : ICloudScriptFunction<FYClaimGeneratorIncomeClientRequest, FYClaimGeneratorIncomeClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    static readonly Random random = new();
+
+    private TitleDataDailyCrateInfo[] PickItems(TitleDataDailyCrateInfo[] items, int numPicks)
+    {
+        var itemList = new (TitleDataDailyCrateInfo item, float cumulativeWeight)[items.Length];
+        float totalWeight = 0;
+
+        for (int i = 0; i < items.Length; i++) {
+            var item = items[i];
+            totalWeight += item.Weight;
+            itemList[i] = (item, totalWeight);
+        }
+
+        var selectedItems = new TitleDataDailyCrateInfo[numPicks];
+
+        for (int i = 0; i < numPicks; i++) {
+            float pick = (float)random.NextDouble() * totalWeight;
+            int left = 0, right = itemList.Length - 1;
+
+            while (left < right) {
+                int mid = (left + right) / 2;
+                if (itemList[mid].cumulativeWeight < pick) {
+                    left = mid + 1;
+                } else {
+                    right = mid;
+                }
+            }
+
+            selectedItems[i] = itemList[left].item;
+        }
+
+        return selectedItems;
+    }
+
+    public ClaimGeneratorIncomeClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYClaimGeneratorIncomeClientResult> ExecuteAsync(FYClaimGeneratorIncomeClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"Generators__2021_09_09", "CharacterTechTreeBonuses", "Balance", "Inventory"}
+        );
+
+        var userGenerators = JsonSerializer.Deserialize<FYPassiveGenerator[]>(userData["Generators__2021_09_09"].Value);
+        var generator = Array.Find(userGenerators, item => item.GeneratorID == request.GeneratorID);
+        if (generator == null) {
+            return new FYClaimGeneratorIncomeClientResult {
+                UserId = userId,
+                Error = "Invalid generator ID",
+            };
+        }
+
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var techTreeBonuses = JsonSerializer.Deserialize<CharacterTechTreeBonuses>(userData["CharacterTechTreeBonuses"].Value);
+
+        var titleData = _titleDataService.Find(new List<string>{"PassiveGenerators", "DailyCrateRewardsPools", "Blueprints"});
+        var passiveGenerators = JsonSerializer.Deserialize<Dictionary<string, TitleDataPassiveGeneratorsInfo>>(titleData["PassiveGenerators"]);
+
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        FYCurrencyItem[] changedCurrencies = [];
+        List<FYCustomItemInfo> grantedItems = [];
+        switch (generator.GeneratorID) {
+            case "playerquarters_gen_kmarks": {
+                var rate = techTreeBonuses.KmarksRate;
+                if (rate == 0) {
+                    return new FYClaimGeneratorIncomeClientResult
+                    {
+                        UserId = userId,
+                        Error = "K-Marks Generator Upgrade is not constructed",
+                    };
+                }
+
+                var generatorData = passiveGenerators[generator.GeneratorID];
+                var hours = (now - generator.LastClaimTime.Seconds) / (60 * generatorData.BaseGenIntervalMinutes);
+                var cap = techTreeBonuses.KmarksCap + generatorData.BaseCap;
+                var claimableAmount = Math.Min(hours * rate, cap);
+                if (claimableAmount == 0) {
+                    return new FYClaimGeneratorIncomeClientResult
+                    {
+                        UserId = userId,
+                        Error = "Generator is not ready yet",
+                    };
+                }
+
+                balance["SC"] += claimableAmount;
+                changedCurrencies = [new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] }];
+                break;
+            }
+            case "playerquarters_gen_aurum": {
+                var rate = techTreeBonuses.AurumRate;
+                if (rate == 0) {
+                    return new FYClaimGeneratorIncomeClientResult
+                    {
+                        UserId = userId,
+                        Error = "Aurum Generator Upgrade is not constructed",
+                    };
+                }
+
+                var generatorData = passiveGenerators[generator.GeneratorID];
+                var hours = (now - generator.LastClaimTime.Seconds) / (60 * generatorData.BaseGenIntervalMinutes);
+                var cap = techTreeBonuses.AurumCap + generatorData.BaseCap;
+                var claimableAmount = (int)Math.Min(hours * rate, cap);
+                if (claimableAmount == 0) {
+                    return new FYClaimGeneratorIncomeClientResult
+                    {
+                        UserId = userId,
+                        Error = "Generator is not ready yet",
+                    };
+                }
+
+                balance["AU"] += claimableAmount;
+                changedCurrencies = [new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] }];
+                break;
+            }
+            case "playerquarters_gen_crate": {
+                var crateTier = techTreeBonuses.CrateTier;
+                if (crateTier == 0) {
+                    return new FYClaimGeneratorIncomeClientResult
+                    {
+                        UserId = userId,
+                        Error = "Crate Generator Upgrade is not constructed",
+                    };
+                }
+
+                var generatorData = passiveGenerators[generator.GeneratorID];
+                var nextClaimTime = generator.LastClaimTime.Seconds + 60 * generatorData.BaseGenIntervalMinutes;
+                if (now < nextClaimTime) {
+                    return new FYClaimGeneratorIncomeClientResult
+                    {
+                        UserId = userId,
+                        Error = "Generator is not ready yet",
+                    };
+                }
+
+                var dailyCrateRewards = JsonSerializer.Deserialize<TitleDataDailyCrateInfo[][]>(titleData["DailyCrateRewardsPools"]);
+                var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+                var rewardsPool = dailyCrateRewards[crateTier - 1];
+
+                var items = PickItems(rewardsPool, 5); // TODO: Not sure how many items were granted
+                // TODO: Stackable? GrantedItems doesn't imply granted OR updated.
+                foreach (var item in items) {
+                    var itemInfo = blueprints[item.Name];
+                    var grantedItem = new FYCustomItemInfo {
+                        ItemId = Guid.NewGuid().ToString(),
+                        Amount = item.Amount,
+                        BaseItemId = item.Name,
+                        Durability = itemInfo.DurabilityMax,
+                        Insurance = "",
+                        InsuranceOwnerPlayfabId = "",
+                        ModData = new FYModItems { M = [] },
+                        Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                        InsuredAttachmentId = "",
+                        PrimaryVanityId = 0,
+                        SecondaryVanityId = 0,
+                        RolledPerks = [],
+                    };
+                    inventory.Add(grantedItem);
+                    grantedItems.Add(grantedItem);
+                }
+                break;
+            }
+            default: {
+                return new FYClaimGeneratorIncomeClientResult
+                {
+                    UserId = userId,
+                    Error = $"Unknown generator ID: {request.GeneratorID}",
+                };
+            }
+        }
+
+        generator.LastClaimTime.Seconds = now;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["Generators__2021_09_09"] = JsonSerializer.Serialize(userGenerators),
+            }
+        );
+
+        return new FYClaimGeneratorIncomeClientResult
+        {
+            UserId = userId,
+            Error = "",
+            GeneratorID = request.GeneratorID,
+            ChangedCurrenciesBalances = changedCurrencies,
+            GrantedItems = grantedItems,
+            LastClaimTime = generator.LastClaimTime,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/ClientsideFriendsImport.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class ClientsideFriendsImportRequest
+{
+    [JsonPropertyName("platform")]
+    public string Platform { get; set; }
+    [JsonPropertyName("userIds")]
+    public string[] UserIDs { get; set; }
+}
+
+public class ClientsideFriendsImportResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("ClientsideFriendsImport")]
+public class ClientsideFriendsImportFunction : ICloudScriptFunction<ClientsideFriendsImportRequest, ClientsideFriendsImportResponse>
+{
+    private readonly ILogger<ClientsideFriendsImportFunction> _logger;
+
+    public ClientsideFriendsImportFunction(ILogger<ClientsideFriendsImportFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<ClientsideFriendsImportResponse> ExecuteAsync(ClientsideFriendsImportRequest request)
+    {
+        _logger.LogInformation("Processing friends import");
+
+        return new ClientsideFriendsImportResponse{};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/EnterMatchmaking.cs

@@ -1,22 +0,0 @@
-using Prospect.Server.Api.Services.CloudScript.Models;
-
-namespace Prospect.Server.Api.Services.CloudScript.Functions;
-
-[CloudScriptFunction("EnterMatchmaking")]
-public class EnterMatchmaking : ICloudScriptFunction<FYEnterMatchAzureFunction, FYEnterMatchAzureFunctionResult>
-{
-    public Task<FYEnterMatchAzureFunctionResult> ExecuteAsync(FYEnterMatchAzureFunction request)
-    {
-        return Task.FromResult(new FYEnterMatchAzureFunctionResult
-        {
-            Success = true,
-            Address = "127.0.0.1",
-            ErrorMessage = "",
-            Port = 7777,
-            ShardIndex = 0,
-            SingleplayerStation = true,
-            MaintenanceMode = false,
-            SessionTimeJoinDelay = 0
-        });
-    }
-}

src/Prospect.Server.Api/Services/CloudScript/Functions/EnterMatchmakingMatch.cs

@@ -0,0 +1,46 @@
+using System.Text.Json.Serialization;
+using Microsoft.AspNetCore.SignalR;
+using Prospect.Server.Api.Hubs;
+using Prospect.Server.Api.Services.CloudScript.Models;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class OnSquadMatchmakingSuccessMessage {
+    [JsonPropertyName("success")]
+    public bool Success { get; set; }
+    [JsonPropertyName("sessionId")]
+    public string SessionID { get; set; }
+    [JsonPropertyName("squadId")]
+    public string SquadID { get; set; }
+}
+
+[CloudScriptFunction("EnterMatchmakingMatch")]
+public class EnterMatchmakingMatchFunction : ICloudScriptFunction<FYEnterMatchAzureFunction, FYEnterMatchmakingResult>
+{
+    private readonly IHubContext<CycleHub> _hubContext;
+
+    public EnterMatchmakingMatchFunction(IHubContext<CycleHub> hubContext)
+    {
+        _hubContext = hubContext;
+    }
+
+    public async Task<FYEnterMatchmakingResult> ExecuteAsync(FYEnterMatchAzureFunction request)
+    {
+        await _hubContext.Clients.All.SendAsync("OnSquadMatchmakingSuccess", new OnSquadMatchmakingSuccessMessage {
+            Success = true,
+            SessionID = request.MapName, // TODO: Need to implement TryGetCompleteSquadInfo and pass squad info
+            SquadID = request.SquadId,
+        });
+
+        return new FYEnterMatchmakingResult
+        {
+            Success = true,
+            ErrorMessage = "",
+            SingleplayerStation = false,
+            NumAttempts = 1,
+            Blocker = 0,
+            IsMatchTravel = true,
+            SessionId = "", // TODO: Not sure how this affects match travel
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/EnterMatchmakingStation.cs

@@ -0,0 +1,18 @@
+using Prospect.Server.Api.Services.CloudScript.Models;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+[CloudScriptFunction("EnterMatchmakingStation")]
+public class EnterMatchmakingStationFunction : ICloudScriptFunction<FYEnterMatchAzureFunction, FYEnterMatchmakingResult>
+{
+    public Task<FYEnterMatchmakingResult> ExecuteAsync(FYEnterMatchAzureFunction request)
+    {
+        return Task.FromResult(new FYEnterMatchmakingResult
+        {
+            Success = true,
+            ErrorMessage = "",
+            SingleplayerStation = true, // NOTE: This will always travel to single player station
+            IsMatchTravel = false,
+        });
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/FetchSteamEntitlements.cs

@@ -0,0 +1,34 @@
+using Prospect.Server.Api.Services.CloudScript;
+
+public class FetchSteamEntitlementsRequest
+{
+    // Empty request
+}
+
+public class FetchSteamEntitlementsResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("FetchSteamEntitlements")]
+public class FetchSteamEntitlementsFunction : ICloudScriptFunction<FetchSteamEntitlementsRequest, FetchSteamEntitlementsResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public FetchSteamEntitlementsFunction(IHttpContextAccessor httpContextAccessor)
+    {
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task<FetchSteamEntitlementsResponse> ExecuteAsync(FetchSteamEntitlementsRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+
+        return new FetchSteamEntitlementsResponse
+        {};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/GetActiveGlobalVanity.cs

@@ -0,0 +1,52 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.UserData;
+
+public class FYActiveGlobalVanity {
+    [JsonPropertyName("activeGlobalVanityIds")]
+    public string[] ActiveGlobalVanityIds { get; set; }
+    [JsonPropertyName("droppodId")]
+    public string DropPodID { get; set; }
+}
+
+public class FYGetActiveGlobalVanityRequest
+{
+    // Empty request
+}
+
+public class FYGetActiveGlobalVanityResponse
+{
+    [JsonPropertyName("activeVanity")]
+    public FYActiveGlobalVanity ActiveVanity { get; set; }
+}
+
+[CloudScriptFunction("GetActiveGlobalVanity")]
+public class GetActiveGlobalVanityFunction : ICloudScriptFunction<FYGetActiveGlobalVanityRequest, FYGetActiveGlobalVanityResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public GetActiveGlobalVanityFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<FYGetActiveGlobalVanityResponse> ExecuteAsync(FYGetActiveGlobalVanityRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"GlobalVanity"});
+        var activeVanity = JsonSerializer.Deserialize<FYActiveGlobalVanity>(userData["GlobalVanity"].Value);
+
+        return new FYGetActiveGlobalVanityResponse{
+            ActiveVanity = activeVanity
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/GetCharacterVanity.cs

@@ -1,67 +1,75 @@
-using Prospect.Server.Api.Services.Auth.Extensions;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
 using Prospect.Server.Api.Services.CloudScript.Models;
+using Prospect.Server.Api.Services.UserData;
 
 namespace Prospect.Server.Api.Services.CloudScript.Functions;
 
+public class FYGetCharacterVanityResponse {
+    [JsonPropertyName("success")]
+    public bool Success { get; set; }
+
+    [JsonPropertyName("returnVanity")]
+    public FYCharacterVanity ReturnVanity { get; set; }
+}
+
+public class FYVanityMaterialItem {
+    [JsonPropertyName("id")]
+    public string ID { get; set; }
+    [JsonPropertyName("materialIndex")]
+    public int MaterialIndex { get; set; }
+}
+
+public class FYCharacterVanity {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("head_item")]
+    public FYVanityMaterialItem HeadItem { get; set; }
+    [JsonPropertyName("boots_item")]
+    public FYVanityMaterialItem BootsItem { get; set; }
+    [JsonPropertyName("chest_item")]
+    public FYVanityMaterialItem ChestItem { get; set; }
+    [JsonPropertyName("glove_item")]
+    public FYVanityMaterialItem GloveItem { get; set; }
+    [JsonPropertyName("base_suit_item")]
+    public FYVanityMaterialItem BaseSuitItem { get; set; }
+    [JsonPropertyName("melee_weapon_item")]
+    public FYVanityMaterialItem MeleeWeaponItem { get; set; }
+    [JsonPropertyName("body_type")]
+    public int BodyType { get; set; }
+    [JsonPropertyName("archetype_id")]
+    public string ArchetypeID { get; set; }
+    [JsonPropertyName("slot_index")]
+    public int SlotIndex { get; set; }
+}
+
 [CloudScriptFunction("GetCharacterVanity")]
-public class GetCharacterVanity : ICloudScriptFunction<FYGetCharacterVanityRequest, object?>
+public class GetCharacterVanity : ICloudScriptFunction<FYGetCharacterVanityRequest, FYGetCharacterVanityResponse?>
 {
     private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
 
-    public GetCharacterVanity(IHttpContextAccessor httpContextAccessor)
+    public GetCharacterVanity(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
     {
         _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
     }
-    
-    public Task<object?> ExecuteAsync(FYGetCharacterVanityRequest request)
+
+    public async Task<FYGetCharacterVanityResponse?> ExecuteAsync(FYGetCharacterVanityRequest request)
     {
         var context = _httpContextAccessor.HttpContext;
         if (context == null)
         {
-            return Task.FromResult<object?>(null);
+            return null;
         }
-        
-        return Task.FromResult<object?>(new
-        {
-            userId = context.User.FindAuthUserId(),
-            error = (object?)null,
-            returnVanity = new
-            {
-                userId = context.User.FindAuthUserId(),
-                head_item = new
-                {
-                    id = "Black02M_Head1",
-                    materialIndex = 0,
-                },
-                boots_item = new
-                {
-                    id = "StarterOutfit01_Boots_M",
-                    materialIndex = 0,
-                },
-                chest_item = new
-                {
-                    id = "StarterOutfit01_Chest_M",
-                    materialIndex = 0,
-                },
-                glove_item = new
-                {
-                    id = "StarterOutfit01_Gloves_M",
-                    materialIndex = 0,
-                },
-                base_suit_item = new
-                {
-                    id = "StarterOutfit01M_BaseSuit",
-                    materialIndex = 0,
-                },
-                melee_weapon_item = new
-                {
-                    id = "Melee_Omega",
-                    materialIndex = 0,
-                },
-                body_type = 1,
-                archetype_id = "TheProspector",
-                slot_index = 0
-            }
-        });
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"CharacterVanity"});
+        var returnVanity = JsonSerializer.Deserialize<FYCharacterVanity>(userData["CharacterVanity"].Value);
+
+        return new FYGetCharacterVanityResponse{
+            Success = true,
+            ReturnVanity = returnVanity,
+        };
     }
 }

src/Prospect.Server.Api/Services/CloudScript/Functions/GetCraftingInProgressData.cs

@@ -26,16 +26,7 @@ public class GetCraftingInProgressData : ICloudScriptFunction<FYGetCraftingInPro
         {
             UserId = context.User.FindAuthUserId(),
             Error = string.Empty,
-            ItemCurrentlyBeingCrafted = new FYItemCurrentlyBeingCrafted
-            {
-                ItemId = null,
-                ItemRarity = -1,
-                PurchaseAmount = -1,
-                UtcTimestampWhenCraftingStarted = new FYTimestamp
-                {
-                    Seconds = 0
-                }
-            }
+            ItemCurrentlyBeingCrafted = {},
         });
     }
 }

src/Prospect.Server.Api/Services/CloudScript/Functions/GetLoginQueuePosition.cs

@@ -0,0 +1,39 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class GetLoginQueuePositionRequest
+{
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+    [JsonPropertyName("region")]
+    public string Region { get; set; }
+}
+
+public class GetLoginQueuePositionResponse
+{
+    [JsonPropertyName("waitingUserCount")]
+    public int WaitingUserCount { get; set; }
+}
+
+[CloudScriptFunction("GetLoginQueuePosition")]
+public class GetLoginQueuePositionFunction : ICloudScriptFunction<GetLoginQueuePositionRequest, GetLoginQueuePositionResponse>
+{
+    private readonly ILogger<GetLoginQueuePositionFunction> _logger;
+
+    public GetLoginQueuePositionFunction(ILogger<GetLoginQueuePositionFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<GetLoginQueuePositionResponse> ExecuteAsync(GetLoginQueuePositionRequest request)
+    {
+        _logger.LogInformation("Processing user rollback if needed");
+
+        return new GetLoginQueuePositionResponse
+        {
+            WaitingUserCount = 0,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/GetPlayerQuartersDataClient.cs

@@ -0,0 +1,77 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+public class GetPlayerQuartersDataClientRequest
+{
+    // Empty request
+}
+
+public class FYGetPlayerQuartersDataClientResponse
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("level")]
+    public int Level { get; set; }
+    [JsonPropertyName("upgradeStartedTime")]
+	public FYTimestamp UpgradeStartedTime { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+}
+
+public class FYPlayerQuarterStatus
+{
+    [JsonPropertyName("level")]
+    public int Level { get; set; }
+    [JsonPropertyName("upgradeStartedTime")]
+	public FYTimestamp UpgradeStartedTime { get; set; }
+}
+
+[CloudScriptFunction("GetPlayerQuartersDataClient")]
+public class GetPlayerQuartersDataClientFunction : ICloudScriptFunction<GetPlayerQuartersDataClientRequest, FYGetPlayerQuartersDataClientResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public GetPlayerQuartersDataClientFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYGetPlayerQuartersDataClientResponse> ExecuteAsync(GetPlayerQuartersDataClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"PlayerQuartersLevel"}
+        );
+        var titleData = _titleDataService.Find(new List<string>{ "PlayerQuarters" });
+
+        var playerQuartersData = JsonSerializer.Deserialize<TitleDataPlayerQuartersInfo[]>(titleData["PlayerQuarters"]);
+        var userPlayerQuarters = JsonSerializer.Deserialize<FYPlayerQuarterStatus>(userData["PlayerQuartersLevel"].Value);
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var remainingTime = 0;
+        if (userPlayerQuarters.UpgradeStartedTime.Seconds != 0) {
+            var nextLevel = playerQuartersData[userPlayerQuarters.Level - 1];
+            remainingTime = userPlayerQuarters.UpgradeStartedTime.Seconds + nextLevel.UpgradeSeconds - now;
+        }
+
+        return new FYGetPlayerQuartersDataClientResponse {
+            UserID = userId,
+            Level = userPlayerQuarters.Level,
+            RemainingTimeInSeconds = remainingTime,
+            UpgradeStartedTime = userPlayerQuarters.UpgradeStartedTime,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/GetPlayerStatisticsRequestsClient.cs

@@ -0,0 +1,38 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+// ["DropsTotal","DeathsTotal","DeathsPlayerTotal","DeathsCreaturesTotal","DeathsOthersTotal","EvacsTotal","DeathsConsecutive","EvacsConsecutive","KillsPlayersTotal","KillsPlayersMax","KillsCreaturesTotal","KillsCreaturesMax","DamagePlayersTotal","DamagePlayersMax","DamageCreaturesTotal","DamageCreaturesMax","ContractsCompletedKorolevTotal","ContractsCompletedOsirisTotal","ContractsCompletedICATotal","ContractsCompletedTotal","MatchDurationMax","MatchDurationAvg","KMarksMatchMax","KMarksMatchTotal","KMarksTotal"]
+public class GetPlayerStatisticsRequestsClientRequest
+{
+    [JsonPropertyName("statistics")]
+    public string[] Statistics { get; set; }
+}
+
+public class GetPlayerStatisticsRequestsClientResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("GetPlayerStatisticsRequestsClient")]
+public class GetPlayerStatisticsRequestsClientFunction : ICloudScriptFunction<GetPlayerStatisticsRequestsClientRequest, GetPlayerStatisticsRequestsClientResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public GetPlayerStatisticsRequestsClientFunction(IHttpContextAccessor httpContextAccessor)
+    {
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task<GetPlayerStatisticsRequestsClientResponse> ExecuteAsync(GetPlayerStatisticsRequestsClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+
+        return new GetPlayerStatisticsRequestsClientResponse
+        {
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/GetSignalRConnection.cs

@@ -9,7 +9,7 @@ public class GetSignalRConnection : ICloudScriptFunction<FYGetSignalRConnection,
     {
         return Task.FromResult(new FYGetSignalRConnectionResult
         {
-            Url = "https://localhost:5443/signalr/?hub=pubsub",
+            Url = "https://2ea46.playfabapi.com/signalr/?hub=pubsub",
             AccessToken = "TEST"
         });
     }

src/Prospect.Server.Api/Services/CloudScript/Functions/GetTechTreeNodeDataClient.cs

@@ -0,0 +1,69 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.CloudScript.Functions;
+using Prospect.Server.Api.Services.UserData;
+
+public class GetTechTreeNodeDataClientRequest
+{
+    // Empty request
+}
+
+public class GetTechTreeNodeDataClientResponse
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("nodesData")]
+    public FYTechTreeNodeStatus[] NodesData { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+    public int RemainingTimeInSeconds { get; set; }
+}
+
+[CloudScriptFunction("GetTechTreeNodeDataClient")]
+public class GetTechTreeNodeDataClientFunction : ICloudScriptFunction<GetTechTreeNodeDataClientRequest, GetTechTreeNodeDataClientResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public GetTechTreeNodeDataClientFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<GetTechTreeNodeDataClientResponse> ExecuteAsync(GetTechTreeNodeDataClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"TechTreeNodeData"}
+        );
+
+        var titleData = _titleDataService.Find(new List<string>{"TechTreeNodes"});
+        var techTreeNodes = JsonSerializer.Deserialize<Dictionary<string, TitleDataTechTreeNodeInfo>>(titleData["TechTreeNodes"]);
+
+        var userTechTree = JsonSerializer.Deserialize<UserTechTreeNodeData>(userData["TechTreeNodeData"].Value);
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var remainingTime = 0;
+        if (userTechTree.NodeInProgress != "") {
+            var nodeInProgress = userTechTree.Nodes[userTechTree.NodeInProgress];
+            var node = techTreeNodes[userTechTree.NodeInProgress];
+            remainingTime = nodeInProgress.UpgradeStartedTime.Seconds + node.PerkLevels[nodeInProgress.Level].UpgradeSeconds - now;
+        }
+        return new GetTechTreeNodeDataClientResponse
+        {
+            UserID = userId,
+            NodesData = userTechTree.Nodes.Values.ToArray(),
+            RemainingTimeInSeconds = remainingTime,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/OnLogin.cs

@@ -0,0 +1,49 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class YOnLoginRequest
+{
+    [JsonPropertyName("gamePlatform")]
+    public string GamePlatform { get; set; }
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+    [JsonPropertyName("customTags")]
+    public Dictionary<string, string> CustomTags { get; set; } = new();
+}
+
+public class OnLoginResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("OnLogin")]
+public class OnLoginFunction : ICloudScriptFunction<YOnLoginRequest, OnLoginResponse>
+{
+    private readonly ILogger<OnLoginFunction> _logger;
+
+    public OnLoginFunction(ILogger<OnLoginFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<OnLoginResponse> ExecuteAsync(YOnLoginRequest request)
+    {
+        _logger.LogInformation("Processing login request for platform {Platform} with nonce {Nonce}",
+            request.GamePlatform, request.LoginNonce);
+
+        // Example: Validate login
+        // if (string.IsNullOrEmpty(request.LoginNonce))
+        // {
+        //     return new OnLoginResponse
+        //     {};
+        // }
+
+        // Simulating user authentication logic
+        var sessionToken = Guid.NewGuid().ToString();
+
+        return new OnLoginResponse
+        {};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/PlayerQuarterUpgradePurchaseClient.cs

@@ -0,0 +1,99 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYPlayerQuarterUpgradePurchaseClientRequest {
+    // Empty request
+}
+
+public class FYPlayerQuarterUpgradePurchaseClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("newLevel")]
+	public int NewLevel { get; set; }
+    [JsonPropertyName("upgradeStartedTime")]
+	public FYTimestamp UpgradeStartedTime { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public FYCustomItemInfo[] ChangedItems { get; set; }
+    [JsonPropertyName("deletedItems")]
+	public string[] DeletedItemsIds { get; set; }
+}
+
+[CloudScriptFunction("PlayerQuarterUpgradePurchaseClient")]
+public class PlayerQuarterUpgradePurchaseClient : ICloudScriptFunction<FYPlayerQuarterUpgradePurchaseClientRequest, FYPlayerQuarterUpgradePurchaseClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public PlayerQuarterUpgradePurchaseClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYPlayerQuarterUpgradePurchaseClientResult> ExecuteAsync(FYPlayerQuarterUpgradePurchaseClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"PlayerQuartersLevel"}
+        );
+
+        var userPlayerQuarters = JsonSerializer.Deserialize<FYPlayerQuarterStatus>(userData["PlayerQuartersLevel"].Value);
+        var titleData = _titleDataService.Find(new List<string>{"PlayerQuarters"});
+        var playerQuarters = JsonSerializer.Deserialize<TitleDataPlayerQuartersInfo[]>(titleData["PlayerQuarters"]);
+
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var endTime = playerQuarters[userPlayerQuarters.Level - 1].UpgradeSeconds + userPlayerQuarters.UpgradeStartedTime.Seconds;
+        if (now < endTime) {
+            return new FYPlayerQuarterUpgradePurchaseClientResult
+            {
+                UserID = userId,
+                Error = "Upgrade is in progress",
+            };
+        }
+
+        var upgradeStartedTime = new FYTimestamp {
+            Seconds = 0,
+        };
+        userPlayerQuarters.Level++;
+        userPlayerQuarters.UpgradeStartedTime = upgradeStartedTime;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["PlayerQuartersLevel"] = JsonSerializer.Serialize(userPlayerQuarters),
+            }
+        );
+
+        return new FYPlayerQuarterUpgradePurchaseClientResult
+        {
+            UserID = userId,
+            Error = "",
+            NewLevel = userPlayerQuarters.Level,
+            UpgradeStartedTime = upgradeStartedTime,
+            RemainingTimeInSeconds = 0,
+            ChangedItems = [],
+            DeletedItemsIds = [],
+            ChangedCurrencies = [],
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/PurchaseWeaponShopItem.cs

@@ -0,0 +1,272 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.UserData;
+
+public class PurchaseWeaponShopItemRequest
+{
+    [JsonPropertyName("blueprintName")]
+    public string BlueprintName { get; set; }
+    [JsonPropertyName("blueprintRarity")]
+    public int BlueprintRarity { get; set; }
+    [JsonPropertyName("purchaseAmount")]
+    public int PurchaseAmount { get; set; }
+    [JsonPropertyName("baseItemId")]
+    public string BaseItemID { get; set; }
+    [JsonPropertyName("shopItemBelongsTo")]
+    public string ShopItemBelongsTo { get; set; }
+}
+
+public class PurchaseWeaponShopItemResponse
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+
+    [JsonPropertyName("itemRarity")]
+    public int ItemRarity { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+    public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("itemsGrantedOrUpdated")]
+    public List<FYCustomItemInfo> ItemsGrantedOrUpdated { get; set; }
+    [JsonPropertyName("deletedItemsIds")]
+    public HashSet<string> DeletedItemsIds { get; set; }
+    [JsonPropertyName("purchaseAmount")]
+    public int PurchaseAmount { get; set; }
+    [JsonPropertyName("blueprintName")]
+    public string BlueprintName { get; set; }
+    [JsonPropertyName("shopItemBelongsTo")]
+    public string ShopItemBelongsTo { get; set; }
+}
+
+public class FYCurrencyItem {
+    [JsonPropertyName("currencyName")]
+    public string CurrencyName { get; set; }
+    [JsonPropertyName("amount")]
+    public int Amount { get; set; }
+}
+
+public class FYModItems {
+    [JsonPropertyName("m")]
+	public int[] M { get; set; } // mods
+};
+
+// FYItemOriginData
+public class FYItemOriginBackend {
+    [JsonPropertyName("t")]
+	public string T { get; set; } // type
+    [JsonPropertyName("p")]
+	public string P { get; set; } // playfabid
+    [JsonPropertyName("g")]
+	public string G { get; set; } // guid
+};
+
+// FYRolledPerkEntry
+public class FYRolledPerkBackend {
+    [JsonPropertyName("i")]
+	public int I { get; set; } // short perk id
+    [JsonPropertyName("r")]
+	public float R { get; set; } // rolled range value
+};
+
+public class FYCustomItemInfo {
+    [JsonPropertyName("itemId")]
+	public string ItemId { get; set; }
+    [JsonPropertyName("baseItemId")]
+	public string BaseItemId { get; set; }
+    [JsonPropertyName("primaryVanityId")] // Item skin
+	public int PrimaryVanityId { get; set; }
+    [JsonPropertyName("secondaryVanityId")] // Item charm
+	public int SecondaryVanityId { get; set; }
+    [JsonPropertyName("amount")]
+	public int Amount { get; set; }
+    [JsonPropertyName("durability")]
+	public int Durability { get; set; }
+    [JsonPropertyName("modData")]
+	public FYModItems ModData { get; set; }
+    [JsonPropertyName("rolledPerks")]
+	public FYRolledPerkBackend[] RolledPerks { get; set; }
+    [JsonPropertyName("insurance")]
+	public string Insurance { get; set; }
+    [JsonPropertyName("insuranceOwnerPlayfabId")]
+	public string InsuranceOwnerPlayfabId { get; set; }
+    [JsonPropertyName("insuredAttachmentId")]
+	public string InsuredAttachmentId { get; set; }
+    [JsonPropertyName("origin")]
+	public FYItemOriginBackend Origin { get; set; }
+};
+
+public class CustomVanityItem {
+    [JsonPropertyName("baseItemId")]
+	public string BaseItemId { get; set; }
+    [JsonPropertyName("origin")]
+	public FYItemOriginBackend Origin { get; set; }
+};
+
+[CloudScriptFunction("PurchaseWeaponShopItem")]
+public class PurchaseWeaponShopItemFunction : ICloudScriptFunction<PurchaseWeaponShopItemRequest, PurchaseWeaponShopItemResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+    private readonly ILogger<PurchaseWeaponShopItemFunction> _logger;
+
+    public PurchaseWeaponShopItemFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService, ILogger<PurchaseWeaponShopItemFunction> logger)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+        _logger = logger;
+    }
+
+    public async Task<PurchaseWeaponShopItemResponse> ExecuteAsync(PurchaseWeaponShopItemRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        if (request.PurchaseAmount <= 0) {
+            return new PurchaseWeaponShopItemResponse
+            {
+                UserID = userId,
+                Error = "Invalid purchase amount",
+            };
+        }
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"Inventory", "Balance"});
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var blueprintsData = _titleDataService.Find(new List<string>{"Blueprints"});
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(blueprintsData["Blueprints"]);
+        if (!blueprints.ContainsKey(request.BaseItemID)) {
+            _logger.LogError("Failed to find item ID {ItemID}", request.BaseItemID);
+            return new PurchaseWeaponShopItemResponse
+            {
+                UserID = userId,
+                Error = "Invalid base item ID",
+            };
+        }
+
+        var blueprintData = blueprints[request.BaseItemID];
+
+        // TODO: Contract unlock criteria
+
+        // Validate price
+        var shopCraftingData = blueprintData.ItemShopsCraftingData[request.ShopItemBelongsTo];
+        // TODO: Refactor
+        List<FYCustomItemInfo> grantedOrUpdated = [];
+        HashSet<string> deletedItemsIds = [];
+        List<FYCurrencyItem> changedCurrencies = [];
+        foreach (var ingredient in shopCraftingData.ItemRecipeIngredients) {
+            int remaining = ingredient.Amount;
+            if (ingredient.Currency == "SoftCurrency") {
+                var buyCost = request.PurchaseAmount * ingredient.Amount;
+                remaining -= buyCost;
+                balance["SC"] -= buyCost;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] });
+            } else if (ingredient.Currency == "Aurum") {
+                var buyCost = request.PurchaseAmount * ingredient.Amount;
+                remaining -= buyCost;
+                balance["AU"] -= buyCost;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] });
+            } else {
+                for (var i = 0; i < inventory.Count; i++) {
+                    var item = inventory[i];
+                    if (item.BaseItemId != ingredient.Currency) {
+                        continue;
+                    }
+                    var localRemaining = remaining;
+                    remaining -= item.Amount;
+                    item.Amount -= localRemaining;
+                    if (item.Amount <= 0) {
+                        item.Amount = 0;
+                        deletedItemsIds.Add(item.ItemId);
+                    } else {
+                        grantedOrUpdated.Add(item);
+                    }
+                    if (remaining <= 0) {
+                        break;
+                    }
+                }
+            }
+            if (remaining > 0) {
+                return new PurchaseWeaponShopItemResponse
+                {
+                    UserID = userId,
+                    Error = "Missing required items",
+                };
+            }
+        }
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!deletedItemsIds.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        // TODO: Refactor into a helper function
+        var remainingAmount = request.PurchaseAmount * blueprintData.AmountPerPurchase;
+
+        // Populate incomplete stacks first
+        foreach (var item in newInventory) {
+            if (item.BaseItemId != request.BaseItemID || item.Amount >= blueprintData.MaxAmountPerStack) {
+                continue;
+            }
+            var remainingSpace = blueprintData.MaxAmountPerStack - item.Amount;
+            var amountToAdd = Math.Min(remainingAmount, remainingSpace);
+            item.Amount += amountToAdd;
+            remainingAmount -= amountToAdd;
+            grantedOrUpdated.Add(item);
+            if (remainingAmount == 0) {
+                break;
+            }
+        }
+
+        // Then create new items
+        while (remainingAmount > 0) {
+            var itemStackAmount = Math.Min(blueprintData.MaxAmountPerStack, remainingAmount);
+            var grantedItem = new FYCustomItemInfo {
+                ItemId = Guid.NewGuid().ToString(),
+                Amount = itemStackAmount,
+                BaseItemId = request.BaseItemID,
+                Durability = blueprintData.DurabilityMax,
+                Insurance = "",
+                InsuranceOwnerPlayfabId = "",
+                ModData = new FYModItems { M = [] },
+                Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                InsuredAttachmentId = "",
+                PrimaryVanityId = 0,
+                SecondaryVanityId = 0,
+                RolledPerks = [],
+            };
+            newInventory.Add(grantedItem);
+            grantedOrUpdated.Add(grantedItem);
+            remainingAmount -= itemStackAmount;
+        }
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Inventory"] = JsonSerializer.Serialize(newInventory),
+                ["Balance"] = JsonSerializer.Serialize(balance),
+            }
+        );
+
+        return new PurchaseWeaponShopItemResponse
+        {
+            UserID = userId,
+            Error = "",
+            BlueprintName = request.BlueprintName,
+            ItemRarity = request.BlueprintRarity,
+            PurchaseAmount = request.PurchaseAmount,
+            ChangedCurrencies = changedCurrencies.ToArray(),
+            DeletedItemsIds = deletedItemsIds,
+            ItemsGrantedOrUpdated = grantedOrUpdated,
+            ShopItemBelongsTo = request.ShopItemBelongsTo
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RefreshVictimCompensationPackages.cs

@@ -0,0 +1,35 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RefreshVictimCompensationPackagesRequest
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+}
+
+public class RefreshVictimCompensationPackagesResponse
+{
+    [JsonPropertyName("compensationPackages")]
+    public object[] CompensationPackages { get; set; }
+}
+
+[CloudScriptFunction("RefreshVictimCompensationPackages")]
+public class RefreshVictimCompensationPackagesFunction : ICloudScriptFunction<RefreshVictimCompensationPackagesRequest, RefreshVictimCompensationPackagesResponse>
+{
+    private readonly ILogger<RefreshVictimCompensationPackagesFunction> _logger;
+
+    public RefreshVictimCompensationPackagesFunction(ILogger<RefreshVictimCompensationPackagesFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<RefreshVictimCompensationPackagesResponse> ExecuteAsync(RefreshVictimCompensationPackagesRequest request)
+    {
+        _logger.LogInformation("Processing refresh victim compensation packages");
+
+        return new RefreshVictimCompensationPackagesResponse
+        {
+            CompensationPackages = [],
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RegisterUserMacAddressRequest.cs

@@ -0,0 +1,33 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RegisterUserMacAddressRequestRequest
+{
+    [JsonPropertyName("macAddress")]
+    public string MacAddress { get; set; }
+}
+
+public class RegisterUserMacAddressRequestResponse
+{
+    [JsonPropertyName("result")]
+    public bool Result { get; set; }
+}
+
+[CloudScriptFunction("RegisterUserMacAddressRequest")]
+public class RegisterUserMacAddressRequestFunction : ICloudScriptFunction<RegisterUserMacAddressRequestRequest, RegisterUserMacAddressRequestResponse>
+{
+    private readonly ILogger<RegisterUserMacAddressRequestFunction> _logger;
+
+    public RegisterUserMacAddressRequestFunction(ILogger<RegisterUserMacAddressRequestFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<RegisterUserMacAddressRequestResponse> ExecuteAsync(RegisterUserMacAddressRequestRequest request)
+    {
+        return new RegisterUserMacAddressRequestResponse
+        {
+            Result = true,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RepairItem.cs

@@ -0,0 +1,102 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+using Prospect.Server.Api.Utils;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYRepairItemRequest {
+    [JsonPropertyName("instanceId")]
+	public string InstanceID { get; set; }
+}
+
+public class FYRepairItemResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public FYCustomItemInfo[] ChangedItems { get; set; }
+}
+
+[CloudScriptFunction("RepairItem")]
+public class RepairItem : ICloudScriptFunction<FYRepairItemRequest, FYRepairItemResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public RepairItem(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYRepairItemResult> ExecuteAsync(FYRepairItemRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var titleData = _titleDataService.Find(new List<string>{"Blueprints"});
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"Balance", "Inventory"}
+        );
+
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+
+        var item = inventory.Find(item => item.ItemId == request.InstanceID);
+        if (item == null) {
+            return new FYRepairItemResult
+            {
+                UserID = userId,
+                Error = "Item not found",
+            };
+        }
+
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+        var blueprintData = blueprints[item.BaseItemId];
+
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+
+        var repairCost = MapValue.Map(item.Durability, blueprintData.DurabilityMax, 0, blueprintData.RepairCostBase, blueprintData.RepairCostMaxDurability);
+        if (item.Durability == 0) {
+            repairCost += blueprintData.RepairCostModifierBroken;
+        }
+        if (balance["SC"] < repairCost) {
+            return new FYRepairItemResult
+            {
+                UserID = userId,
+                Error = "Insufficient balance",
+            };
+        }
+        balance["SC"] -= repairCost;
+        item.Durability = blueprintData.DurabilityMax;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+                ["Balance"] = JsonSerializer.Serialize(balance),
+            }
+        );
+
+        return new FYRepairItemResult
+        {
+            UserID = userId,
+            Error = "",
+            ChangedItems = [item],
+            ChangedCurrencies = [
+                new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] },
+            ],
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/ReportBiEvents.cs

@@ -0,0 +1,31 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class ReportBiEventsRequest
+{
+    [JsonPropertyName("messages")]
+    public object[] Messages { get; set; }
+}
+
+public class ReportBiEventsResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("ReportBiEvents")]
+public class ReportBiEventsFunction : ICloudScriptFunction<ReportBiEventsRequest, ReportBiEventsResponse>
+{
+    private readonly ILogger<ReportBiEventsFunction> _logger;
+
+    public ReportBiEventsFunction(ILogger<ReportBiEventsFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<ReportBiEventsResponse> ExecuteAsync(ReportBiEventsRequest request)
+    {
+        _logger.LogInformation("Processing Bi Event");
+
+        return new ReportBiEventsResponse{};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestActiveObjectivesAndBoardsData.cs

@@ -0,0 +1,109 @@
+using System.Text.Json;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+[CloudScriptFunction("RequestActiveObjectivesAndBoardsData")]
+public class RequestActiveObjectivesAndBoardsData : ICloudScriptFunction<FYQueryFactionProgressionRequest, FYGetPlayerContractsResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public RequestActiveObjectivesAndBoardsData(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<FYGetPlayerContractsResult> ExecuteAsync(FYQueryFactionProgressionRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            return new FYGetPlayerContractsResult{};
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"ContractsActive"});
+        var contractsActive = JsonSerializer.Deserialize<FYGetActiveContractsResult>(userData["ContractsActive"].Value);
+
+        // TODO: Get player's contract boards and refresh
+
+        return new FYGetPlayerContractsResult
+        {
+            UserId = userId,
+            Error = null,
+            ActiveContracts = contractsActive.Contracts,
+            FactionsContracts = new FYFactionsContractsData
+            {
+                Boards = new List<FYFactionContractsData>
+                {
+                    new FYFactionContractsData
+                    {
+                        FactionId = "ICA",
+                        Contracts = new List<FYFactionContractData>
+                        {
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Easy-ICA-Gather-1",
+                            },
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Medium-ICA-Uplink-1",
+                            },
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Hard-ICA-Uplink-1",
+                            }
+                        }
+                    },
+                    new FYFactionContractsData
+                    {
+                        FactionId = "Korolev",
+                        Contracts = new List<FYFactionContractData>
+                        {
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Easy-KOR-Mine-4",
+                            },
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Medium-KOR-Mine-1",
+                            },
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Hard-KOR-PvP-6",
+                            }
+                        }
+                    },
+                    new FYFactionContractsData
+                    {
+                        FactionId = "Osiris",
+                        Contracts = new List<FYFactionContractData>
+                        {
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Easy-Osiris-Brightcaps-1",
+                            },
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Medium-Osiris-Gather-1",
+                            },
+                            new FYFactionContractData
+                            {
+                                ContractId = "NEW-Hard-Osiris-Gather-7",
+                            }
+                        }
+                    }
+                },
+                LastBoardRefreshTimeUtc = new FYTimestamp
+                {
+                    Seconds = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds()
+                }
+            },
+            RefreshHours24UtcFromBackend = 12
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestCanReconnect.cs

@@ -0,0 +1,58 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RequestCanReconnectRequest
+{
+    // Empty request
+}
+
+public class RequestCanReconnectResponse
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    //[JsonPropertyName("error")]
+    //public int Error { get; set; }
+    //[JsonPropertyName("changedItems")]
+    //public int changedItems { get; set; }
+    //[JsonPropertyName("sessionId")]
+    //public int SessionID { get; set; }
+    //[JsonPropertyName("info")]
+    //public int Info { get; set; }
+    //[JsonPropertyName("lastSessionResult")]
+    //public int LastSessionResult { get; set; }
+    //[JsonPropertyName("lastSessionId")]
+    //public int LastSessionID { get; set; }
+}
+
+[CloudScriptFunction("RequestCanReconnect")]
+public class RequestCanReconnectFunction : ICloudScriptFunction<RequestCanReconnectRequest, RequestCanReconnectResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public RequestCanReconnectFunction(IHttpContextAccessor httpContextAccessor)
+    {
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task<RequestCanReconnectResponse> ExecuteAsync(RequestCanReconnectRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            return new RequestCanReconnectResponse
+            {};
+        }
+
+        return new RequestCanReconnectResponse
+        {
+            //Error = 0,
+            //Info = 0,
+            //LastSessionResult = 0,
+            //LastSessionID = 0,
+            //SessionID = 0,
+            //changedItems = 0,
+            UserID = context.User.FindAuthUserId(),
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestClaimFortunaPassRewards.cs

@@ -0,0 +1,76 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.UserData;
+
+public class FYFortunaPassClaimedRewards {
+    [JsonPropertyName("rewardsIds")]
+	public List<string> RewardsIDs { get; set; }
+};
+
+public class RequestClaimFortunaPassRewardsRequest
+{
+    [JsonPropertyName("rewardsIds")]
+    public string[] RewardsIDs { get; set; }
+}
+
+public class RequestClaimFortunaPassRewardsResponse
+{
+    [JsonPropertyName("userIds")]
+    public string UserId { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("errorType")]
+	public int ErrorType { get; set; }
+    [JsonPropertyName("grantedItems")]
+	public FYCustomItemInfo[] GrantedItems { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+}
+
+[CloudScriptFunction("RequestClaimFortunaPassRewards")]
+public class RequestClaimFortunaPassRewardsFunction : ICloudScriptFunction<RequestClaimFortunaPassRewardsRequest, RequestClaimFortunaPassRewardsResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public RequestClaimFortunaPassRewardsFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<RequestClaimFortunaPassRewardsResponse> ExecuteAsync(RequestClaimFortunaPassRewardsRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"FortunaPass2_ClaimedRewards"});
+        var claimedRewards = JsonSerializer.Deserialize<FYFortunaPassClaimedRewards>(userData["FortunaPass2_ClaimedRewards"].Value);
+        foreach (var rewardId in request.RewardsIDs) {
+            claimedRewards.RewardsIDs.Add(rewardId);
+        }
+
+        var output = JsonSerializer.Serialize(claimedRewards);
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["FortunaPass2_ClaimedRewards"] = output,
+                ["FortunaPass3_ClaimedRewards"] = output, // TODO: Separate logic for S2 and S3
+            }
+        );
+
+        return new RequestClaimFortunaPassRewardsResponse
+        {
+            UserId = userId,
+            ErrorType = 3, // EYFortunaPassToastReponseType::Ok
+            Error = "",
+            GrantedItems = [],
+            ChangedCurrencies = [],
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestIsPlayerStillOnBattleServer.cs

@@ -0,0 +1,34 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+// Season 1 request
+public class RequestIsPlayerStillOnBattleServerRequest
+{
+}
+
+public class RequestIsPlayerStillOnBattleServerResponse
+{
+    [JsonPropertyName("isStillOnBattleServer")]
+	public bool IsStillOnBattleServer { get; set; }
+	[JsonPropertyName("infoStillOnBattleServer")]
+    public string InfoStillOnBattleServer { get; set; }
+}
+
+[CloudScriptFunction("RequestIsPlayerStillOnBattleServer")]
+public class RequestIsPlayerStillOnBattleServerFunction : ICloudScriptFunction<RequestIsPlayerStillOnBattleServerRequest, RequestIsPlayerStillOnBattleServerResponse>
+{
+    private readonly ILogger<RequestIsPlayerStillOnBattleServerFunction> _logger;
+
+    public RequestIsPlayerStillOnBattleServerFunction(ILogger<RequestIsPlayerStillOnBattleServerFunction> logger)
+    {
+        _logger = logger;
+    }
+    public async Task<RequestIsPlayerStillOnBattleServerResponse> ExecuteAsync(RequestIsPlayerStillOnBattleServerRequest request)
+    {
+        return new RequestIsPlayerStillOnBattleServerResponse
+        {
+            IsStillOnBattleServer = false,
+            InfoStillOnBattleServer = "",
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestMigrateSteamAccountFromCB1.cs

@@ -0,0 +1,31 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RequestMigrateSteamAccountFromCB1Request
+{
+    [JsonPropertyName("steamId")]
+    public string SteamID { get; set; }
+}
+
+public class RequestMigrateSteamAccountFromCB1Response
+{}
+
+[CloudScriptFunction("RequestMigrateSteamAccountFromCB1")]
+public class RequestMigrateSteamAccountFromCB1Function : ICloudScriptFunction<RequestMigrateSteamAccountFromCB1Request, RequestMigrateSteamAccountFromCB1Response>
+{
+    private readonly ILogger<RequestMigrateSteamAccountFromCB1Function> _logger;
+
+    public RequestMigrateSteamAccountFromCB1Function(ILogger<RequestMigrateSteamAccountFromCB1Function> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<RequestMigrateSteamAccountFromCB1Response> ExecuteAsync(RequestMigrateSteamAccountFromCB1Request request)
+    {
+        _logger.LogInformation("Processing CB1 account migration request request for Steam account {SteamID}",
+            request.SteamID);
+
+        return new RequestMigrateSteamAccountFromCB1Response
+        {};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestMissionCompleted.cs

@@ -0,0 +1,125 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYRequestMissionCompletedRequest {
+    [JsonPropertyName("currentMissionId")]
+    public string CurrentMissionID { get; set; }
+}
+
+public class FYRequestMissionCompletedResult {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("currentMissionId")]
+    public string CurrentMissionID { get; set; }
+    [JsonPropertyName("rewards")]
+    public List<FYCustomItemInfo> Rewards { get; set; }
+    [JsonPropertyName("updatedCurrencies")]
+    public FYCurrencyItem[] UpdatedCurrencies { get; set; }
+    [JsonPropertyName("progress")]
+    public int Progress { get; set; }
+}
+
+[CloudScriptFunction("RequestMissionCompleted")]
+public class RequestMissionCompleted : ICloudScriptFunction<FYRequestMissionCompletedRequest, FYRequestMissionCompletedResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public RequestMissionCompleted(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYRequestMissionCompletedResult> ExecuteAsync(FYRequestMissionCompletedRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"OnboardingProgression", "Inventory", "Balance"});
+        var onboardingMission = JsonSerializer.Deserialize<OnboardingMission>(userData["OnboardingProgression"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+
+        var titleData = _titleDataService.Find(new List<string>{"OnboardingMissions", "OnboardingRewardMissions", "Blueprints"});
+        var rewards = JsonSerializer.Deserialize<Dictionary<string, TitleDataMissionRewardInfo>>(titleData["OnboardingRewardMissions"]);
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+        var missions = JsonSerializer.Deserialize<Dictionary<string, TitleDataMissionInfo>>(titleData["OnboardingMissions"]);
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+
+        var currentMission = missions[onboardingMission.CurrentMissionID];
+        var missionRewardId = currentMission.OnboardingRewards.RowName;
+        var nextMissionId = currentMission.NextMissionRowHandle.RowName;
+        onboardingMission.CurrentMissionID = nextMissionId;
+        onboardingMission.Progress = 0;
+
+        List<FYCustomItemInfo> rewardedItems = new List<FYCustomItemInfo>();
+        List<FYCurrencyItem> changedCurrencies = [];
+        if (rewards.ContainsKey(missionRewardId)) {
+            var missionRewards = rewards[missionRewardId].RewardEntries;
+            foreach (var reward in missionRewards) {
+                if (reward.RewardRowHandle.RowName == "SoftCurrency") {
+                    balance["SC"] += reward.RewardAmount;
+                    changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] });
+                } else if (reward.RewardRowHandle.RowName == "Aurum") {
+                    balance["AU"] += reward.RewardAmount;
+                    changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] });
+                } else if (reward.RewardRowHandle.RowName == "InsuranceToken") {
+                    balance["IN"] += reward.RewardAmount;
+                    changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "InsuranceToken", Amount = balance["IN"] });
+                } else {
+                    var blueprintData = blueprints[reward.RewardRowHandle.RowName];
+                    var remainingAmount = reward.RewardAmount * blueprintData.AmountPerPurchase;
+                    while (remainingAmount > 0) {
+                        var itemStackAmount = Math.Min(blueprintData.MaxAmountPerStack, remainingAmount);
+                        // TODO: Mission rewards are probably already given in stacks
+                        var itemInfo = new FYCustomItemInfo{
+                            ItemId = Guid.NewGuid().ToString(),
+                            Amount = itemStackAmount,
+                            BaseItemId = reward.RewardRowHandle.RowName,
+                            Durability = blueprintData.DurabilityMax,
+                            Insurance = "",
+                            InsuranceOwnerPlayfabId = "",
+                            ModData = new FYModItems { M = [] },
+                            Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                            InsuredAttachmentId = "",
+                            PrimaryVanityId = 0,
+                            SecondaryVanityId = 0,
+                            RolledPerks = [],
+                        };
+                        inventory.Add(itemInfo);
+                        rewardedItems.Add(itemInfo);
+                        remainingAmount -= itemStackAmount;
+                    }
+                }
+            }
+        }
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["OnboardingProgression"] = JsonSerializer.Serialize(onboardingMission),
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+                ["Balance"] = JsonSerializer.Serialize(balance),
+            }
+        );
+
+        return new FYRequestMissionCompletedResult
+        {
+            UserID = userId,
+            CurrentMissionID = nextMissionId,
+            Rewards = rewardedItems,
+            UpdatedCurrencies = changedCurrencies.ToArray(),
+            Progress = 0
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestMissionUpdate.cs

@@ -0,0 +1,83 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYRequestMissionUpdateRequest {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("currentMissionId")]
+    public string CurrentMissionID { get; set; }
+    [JsonPropertyName("currentStepName")]
+    public string CurrentStepName { get; set; }
+    [JsonPropertyName("progress")]
+    public int Progress { get; set; }
+    [JsonPropertyName("currentRoomId")]
+    public string CurrentRoomID { get; set; }
+}
+
+public class FYRequestMissionUpdateResult {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+    [JsonPropertyName("currentMissionId")]
+    public string CurrentMissionID { get; set; }
+    [JsonPropertyName("rewards")]
+    public object[] Rewards { get; set; }
+    [JsonPropertyName("progress")]
+    public int Progress { get; set; }
+}
+
+public class OnboardingMission {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("currentMissionID")]
+    public string CurrentMissionID { get; set; }
+    [JsonPropertyName("progress")]
+    public int Progress { get; set; }
+    [JsonPropertyName("showPopup")]
+    public bool ShowPopup { get; set; }
+}
+
+[CloudScriptFunction("RequestMissionUpdate")]
+public class RequestMissionUpdate : ICloudScriptFunction<FYRequestMissionUpdateRequest, FYRequestMissionUpdateResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public RequestMissionUpdate(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<FYRequestMissionUpdateResult> ExecuteAsync(FYRequestMissionUpdateRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"OnboardingProgression"});
+        var onboardingMission = JsonSerializer.Deserialize<OnboardingMission>(userData["OnboardingProgression"].Value);
+        onboardingMission.CurrentMissionID = request.CurrentMissionID;
+        onboardingMission.Progress = request.Progress;
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{ ["OnboardingProgression"] = JsonSerializer.Serialize(onboardingMission) }
+        );
+
+        return new FYRequestMissionUpdateResult
+        {
+            UserID = userId,
+            Error = "",
+            CurrentMissionID = request.CurrentMissionID,
+            Rewards = [],
+            Progress = request.Progress
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestNewLegalAgreements.cs

@@ -0,0 +1,50 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RequestNewLegalAgreementsRequest
+{
+    [JsonPropertyName("gamePlatform")]
+    public string GamePlatform { get; set; }
+    [JsonPropertyName("nDAVersion")]
+    public int NDAVersion { get; set; }
+    [JsonPropertyName("eULAVersion")]
+    public int EULAVersion { get; set; }
+    [JsonPropertyName("tryBypass")]
+    public bool TryBypass { get; set; }
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+}
+
+public class RequestNewLegalAgreementsResponse
+{
+    [JsonPropertyName("requiredNDAVersion")]
+    public int NDAVersion { get; set; }
+    [JsonPropertyName("requiredEULAVersion")]
+    public int EULAVersion { get; set; }
+    [JsonPropertyName("hasAccepted")]
+    public int HasAccepted { get; set; }
+}
+
+[CloudScriptFunction("RequestNewLegalAgreements")]
+public class RequestNewLegalAgreementsFunction : ICloudScriptFunction<RequestNewLegalAgreementsRequest, RequestNewLegalAgreementsResponse>
+{
+    private readonly ILogger<RequestNewLegalAgreementsFunction> _logger;
+
+    public RequestNewLegalAgreementsFunction(ILogger<RequestNewLegalAgreementsFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<RequestNewLegalAgreementsResponse> ExecuteAsync(RequestNewLegalAgreementsRequest request)
+    {
+        _logger.LogInformation("Processing request new legal agreements for platform {Platform} with nonce {Nonce}",
+            request.GamePlatform, request.LoginNonce);
+
+        return new RequestNewLegalAgreementsResponse
+        {
+            NDAVersion = request.NDAVersion,
+            EULAVersion = request.EULAVersion,
+            HasAccepted = 1,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestPlayerContracts.cs

@@ -39,17 +39,14 @@ public class RequestPlayerContracts : ICloudScriptFunction<FYGetPlayerContractsR
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Easy-ICA-Gather-1",
-                                ContractIsLockedDueToLowFactionReputation = false
                             },
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Medium-ICA-Uplink-1",
-                                ContractIsLockedDueToLowFactionReputation = false
                             },
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Hard-ICA-Uplink-1",
-                                ContractIsLockedDueToLowFactionReputation = false
                             }
                         }
                     },
@@ -61,17 +58,14 @@ public class RequestPlayerContracts : ICloudScriptFunction<FYGetPlayerContractsR
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Easy-KOR-Mine-4",
-                                ContractIsLockedDueToLowFactionReputation = false
                             },
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Medium-KOR-Mine-1",
-                                ContractIsLockedDueToLowFactionReputation = false
                             },
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Hard-KOR-PvP-6",
-                                ContractIsLockedDueToLowFactionReputation = false
                             }
                         }
                     },
@@ -83,17 +77,14 @@ public class RequestPlayerContracts : ICloudScriptFunction<FYGetPlayerContractsR
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Easy-Osiris-Brightcaps-1",
-                                ContractIsLockedDueToLowFactionReputation = false
                             },
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Medium-Osiris-Gather-1",
-                                ContractIsLockedDueToLowFactionReputation = false
                             },
                             new FYFactionContractData
                             {
                                 ContractId = "NEW-Hard-Osiris-Gather-7",
-                                ContractIsLockedDueToLowFactionReputation = false
                             }
                         }
                     }

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestServerSessionState.cs

@@ -0,0 +1,65 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class FYMatchConnectionData {
+    [JsonPropertyName("addr")]
+    public string Addr { get; set; }
+    [JsonPropertyName("sessionId")]
+    public string SessionID { get; set; }
+    [JsonPropertyName("serverId")]
+    public string ServerID { get; set; }
+    [JsonPropertyName("connectSinglePlayer")]
+    public bool ConnectSinglePlayer { get; set; }
+    [JsonPropertyName("isMatch")]
+    public bool IsMatch { get; set; }
+}
+
+public class RequestServerSessionStateRequest
+{
+    [JsonPropertyName("sessionId")]
+    public string SessionID { get; set; }
+    [JsonPropertyName("amountRequests")]
+    public int AmountRequests { get; set; }
+}
+
+public class RequestServerSessionStateResponse
+{
+    [JsonPropertyName("connectionData")]
+    public FYMatchConnectionData ConnectionData { get; set; }
+    [JsonPropertyName("retryCounter")]
+    public int RetryCounter { get; set; }
+    [JsonPropertyName("canGoToSession")]
+    public bool CanGoToSession { get; set; }
+    [JsonPropertyName("shouldCancel")]
+    public bool ShouldCancel { get; set; }
+}
+
+[CloudScriptFunction("RequestServerSessionState")]
+public class RequestServerSessionStateFunction : ICloudScriptFunction<RequestServerSessionStateRequest, RequestServerSessionStateResponse>
+{
+    private readonly ILogger<RequestServerSessionStateFunction> _logger;
+
+    public RequestServerSessionStateFunction(ILogger<RequestServerSessionStateFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<RequestServerSessionStateResponse> ExecuteAsync(RequestServerSessionStateRequest request)
+    {
+        _logger.LogInformation("Processing server session state");
+
+        return new RequestServerSessionStateResponse
+        {
+            CanGoToSession = true,
+            ConnectionData = new FYMatchConnectionData {
+                Addr = request.SessionID, // FIXME: This is for offline use case only!,
+                ConnectSinglePlayer = false,
+                IsMatch = true,
+                ServerID = "testserver",
+                SessionID = request.SessionID,
+            },
+            ShouldCancel = false,
+            RetryCounter = 1,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestStoreRotationData.cs

@@ -0,0 +1,61 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RequestStoreRotationDataRequest
+{
+    // Empty request
+}
+
+public class StoreRotationData
+{
+    [JsonPropertyName("storeId")]
+    public string StoreID { get; set; }
+    [JsonPropertyName("expirationData")]
+    public DateTime ExpirationData { get; set; }
+}
+
+public class RequestStoreRotationDataResponse
+{
+    [JsonPropertyName("dailyStoreData")]
+    public StoreRotationData DailyStoreData { get; set; }
+    [JsonPropertyName("weeklyStoreData")]
+    public StoreRotationData WeeklyStoreData { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+}
+
+[CloudScriptFunction("RequestStoreRotationData")]
+public class RequestStoreRotationDataFunction : ICloudScriptFunction<RequestStoreRotationDataRequest, RequestStoreRotationDataResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public RequestStoreRotationDataFunction(IHttpContextAccessor httpContextAccessor)
+    {
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task<RequestStoreRotationDataResponse> ExecuteAsync(RequestStoreRotationDataRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+
+        // TODO: Get and save store rotation data
+
+        return new RequestStoreRotationDataResponse
+        {
+            Error = "",
+            DailyStoreData = new StoreRotationData {
+                StoreID = "DailyShop",
+                ExpirationData = DateTime.UtcNow.AddDays(1)
+            },
+            WeeklyStoreData = new StoreRotationData {
+                StoreID = "WeeklyShop",
+                ExpirationData = DateTime.UtcNow.AddDays(1)
+            }
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestUpdateSeasonWipeData.cs

@@ -0,0 +1,44 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RequestUpdateSeasonWipeDataRequest
+{
+}
+
+public class RequestUpdateSeasonWipeDataResponse
+{
+    [JsonPropertyName("userId")]
+	public string UserId;
+    [JsonPropertyName("error")]
+	public string Error;
+}
+
+[CloudScriptFunction("RequestUpdateSeasonWipeData")]
+public class RequestUpdateSeasonWipeDataFunction : ICloudScriptFunction<RequestUpdateSeasonWipeDataRequest, RequestUpdateSeasonWipeDataResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly ILogger<RequestUpdateSeasonWipeDataFunction> _logger;
+
+    public RequestUpdateSeasonWipeDataFunction(ILogger<RequestUpdateSeasonWipeDataFunction> logger, IHttpContextAccessor httpContextAccessor)
+    {
+        _logger = logger;
+        _httpContextAccessor = httpContextAccessor;
+    }
+
+    public async Task<RequestUpdateSeasonWipeDataResponse> ExecuteAsync(RequestUpdateSeasonWipeDataRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        return new RequestUpdateSeasonWipeDataResponse
+        {
+            UserId = userId,
+            Error = "",
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestUpdateStationInventory.cs

@@ -0,0 +1,118 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.CloudScript.Models;
+using Prospect.Server.Api.Services.UserData;
+
+public class LoadoutData {
+    [JsonPropertyName("shield")]
+    public string Shield {  get; set; }
+    [JsonPropertyName("helmet")]
+    public string Helmet { get; set; }
+    [JsonPropertyName("weaponOne")]
+    public string WeaponOne { get; set; }
+    [JsonPropertyName("weaponTwo")]
+    public string WeaponTwo { get; set; }
+    [JsonPropertyName("bag")]
+    public string Bag { get; set; }
+    [JsonPropertyName("bagItemsAsJsonStr")]
+    public string BagItemsAsJsonStr { get; set; }
+    [JsonPropertyName("safeItemsAsJsonStr")]
+    public string SafeItemsAsJsonStr { get; set; }
+}
+
+public class RequestUpdateStationInventoryRequest
+{
+    [JsonPropertyName("newSet")]
+    public LoadoutData NewSet { get; set; }
+    [JsonPropertyName("itemsToAdd")]
+    public FYCustomItemInfo[] ItemsToAdd { get; set; }
+    [JsonPropertyName("itemsToUpdateAmount")]
+    public FYCustomItemInfo[] ItemsToUpdateAmount { get; set; }
+    [JsonPropertyName("itemsToRemove")]
+    public HashSet<string> ItemsToRemove { get; set; }
+}
+
+public class RequestUpdateStationInventoryResponse
+{
+    // [JsonPropertyName("userId")]
+    // public string UserId {  get; set; }
+    // [JsonPropertyName("error")]
+    // public string Error {  get; set; }
+    // [JsonPropertyName("newSet")]
+    // public LoadoutData NewSet {  get; set; }
+    // [JsonPropertyName("itemsToAdd")]
+    // public FYCustomItemInfo[] ItemsToAdd { get; set; }
+    // [JsonPropertyName("itemsToUpdateAmount")]
+    // public string[] ItemsToUpdateAmount { get; set; }
+    // [JsonPropertyName("itemsToRemove")]
+    // public string[] ItemsToRemove { get; set; }
+}
+
+[CloudScriptFunction("RequestUpdateStationInventory")]
+public class RequestUpdateStationInventoryFunction : ICloudScriptFunction<RequestUpdateStationInventoryRequest, RequestUpdateStationInventoryResponse>
+{
+    private readonly ILogger<RequestUpdateStationInventoryFunction> _logger;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public RequestUpdateStationInventoryFunction(ILogger<RequestUpdateStationInventoryFunction> logger, IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _logger = logger;
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<RequestUpdateStationInventoryResponse> ExecuteAsync(RequestUpdateStationInventoryRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"Inventory"});
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!request.ItemsToRemove.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        // TODO: Check deleted items to see if other stacks/mods were updated correctly
+        foreach (var item in request.ItemsToUpdateAmount) {
+            var inventoryItem = newInventory.Find(i => i.ItemId == item.ItemId);
+            if (inventoryItem == null) {
+                continue;
+            }
+            inventoryItem.Amount = item.Amount;
+            inventoryItem.ModData = item.ModData;
+            inventoryItem.PrimaryVanityId = item.PrimaryVanityId;
+            inventoryItem.SecondaryVanityId = item.SecondaryVanityId;
+        }
+
+        // TODO: Check updated items and validate new items
+        foreach (var item in request.ItemsToAdd) {
+            newInventory.Add(item);
+        }
+
+        await _userDataService.UpdateAsync(userId, userId, new Dictionary<string, string>{
+            ["LOADOUT"] = JsonSerializer.Serialize(request.NewSet),
+            ["Inventory"] = JsonSerializer.Serialize(newInventory),
+        });
+
+        return new RequestUpdateStationInventoryResponse
+        {
+            // UserId = userId,
+            // Error = "",
+            // NewSet = request.NewSet,
+            // ItemsToAdd = [],
+            // ItemsToRemove = request.ItemsToRemove,
+            // ItemsToUpdateAmount = request.ItemsToUpdateAmount,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/RequestUsersPingRequest.cs

@@ -0,0 +1,45 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class RegionObject
+{
+    [JsonPropertyName("region")]
+    public string Region { get; set; }
+    [JsonPropertyName("ping")]
+    public int Ping { get; set; }
+    [JsonPropertyName("instanceType")]
+    public int InstanceType { get; set; }
+}
+
+public class RequestUsersPingRequestRequest
+{
+    [JsonPropertyName("pings")]
+    public RegionObject[] Pings { get; set; }
+    [JsonPropertyName("countryCode")]
+    public string CountryCode { get; set; }
+}
+
+public class RequestUsersPingRequestResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("RequestUsersPingRequest")]
+public class RequestUsersPingRequestFunction : ICloudScriptFunction<RequestUsersPingRequestRequest, RequestUsersPingRequestResponse>
+{
+    private readonly ILogger<RequestUsersPingRequestFunction> _logger;
+
+    public RequestUsersPingRequestFunction(ILogger<RequestUsersPingRequestFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<RequestUsersPingRequestResponse> ExecuteAsync(RequestUsersPingRequestRequest request)
+    {
+        _logger.LogInformation("Processing ping request");
+
+        return new RequestUsersPingRequestResponse
+        {
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/ResetActionsCapPlayer.cs

@@ -0,0 +1,71 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class ResetActionsCapPlayerRequest
+{
+    // Empty request
+}
+
+public class ResetActionsCapPlayerResponse
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+}
+
+public class FortunaPassDailyCompletedActions {
+    [JsonPropertyName("actions")]
+    public object Actions { get; set; }
+    [JsonPropertyName("lastDailyCapResetTimeUtc")]
+    public FYTimestamp LastDailyCapResetTimeUtc { get; set; }
+}
+
+[CloudScriptFunction("ResetActionsCapPlayer")]
+public class ResetActionsCapPlayer : ICloudScriptFunction<ResetActionsCapPlayerRequest, ResetActionsCapPlayerResponse>
+{
+    private readonly UserDataService _userDataService;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public ResetActionsCapPlayer(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<ResetActionsCapPlayerResponse> ExecuteAsync(ResetActionsCapPlayerRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"FortunaPass2_DailyCompletedActions"});
+
+        var dailyCompletedActions = JsonSerializer.Deserialize<FortunaPassDailyCompletedActions>(userData["FortunaPass2_DailyCompletedActions"].Value);
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        if (now <= dailyCompletedActions.LastDailyCapResetTimeUtc.Seconds + 86400) {
+            return new ResetActionsCapPlayerResponse {
+                UserID = userId,
+                Error = "",
+            };
+        }
+
+        dailyCompletedActions.LastDailyCapResetTimeUtc.Seconds = now;
+        await _userDataService.UpdateAsync(userId, userId, new Dictionary<string, string>{
+            ["FortunaPass2_DailyCompletedActions"] = JsonSerializer.Serialize(dailyCompletedActions), // Season 2
+            ["FortunaPass3_DailyCompletedActions"] = JsonSerializer.Serialize(dailyCompletedActions), // Season 3
+        });
+
+        return new ResetActionsCapPlayerResponse{
+            UserID = userId,
+            Error = "",
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SellItemClient.cs

@@ -0,0 +1,148 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.UserData;
+using Prospect.Server.Api.Utils;
+
+public class SellItemsClientRequest
+{
+    [JsonPropertyName("ids")]
+    public string[] IDs { get; set; }
+    [JsonPropertyName("factionId")]
+    public string FactionID { get; set; }
+    [JsonPropertyName("inventoryUpdateData")]
+    public SellItemsClientInventoryData InventoryUpdateData { get; set; }
+}
+
+public class SellItemsClientInventoryData {
+    [JsonPropertyName("itemsToAdd")]
+    public FYCustomItemInfo[] ItemsToAdd { get; set; }
+    [JsonPropertyName("itemsToUpdateAmount")]
+    public FYCustomItemInfo[] ItemsToUpdateAmount { get; set; }
+    [JsonPropertyName("itemsToRemove")]
+    public HashSet<string> ItemsToRemove { get; set; }
+}
+
+public class SellItemsClientResponse
+{
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+    [JsonPropertyName("scrappedItemIds")]
+    public HashSet<string> ScrappedItemIDs { get; set; }
+    [JsonPropertyName("changedItems")]
+    public FYCustomItemInfo[] ChangedItems { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+    public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("playerFactionProgressionData")]
+    public FYPlayerFactionProgressData PlayerFactionProgressionData { get; set; }
+}
+
+public class FYPlayerFactionProgressData {
+    [JsonPropertyName("factionId")]
+    public string FactionID { get; set; }
+    [JsonPropertyName("currentProgression")]
+    public int CurrentProgression { get; set; }
+}
+
+[CloudScriptFunction("SellItemsClient")]
+public class SellItemsClientFunction : ICloudScriptFunction<SellItemsClientRequest, SellItemsClientResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+    private readonly ILogger<SellItemsClientFunction> _logger;
+
+    public SellItemsClientFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService, ILogger<SellItemsClientFunction> logger)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+        _logger = logger;
+    }
+
+    public async Task<SellItemsClientResponse> ExecuteAsync(SellItemsClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var progressionFactionKey = "FactionProgression" + request.FactionID;
+
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"Inventory", "Balance", progressionFactionKey});
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var balanceData = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var factionProgression = JsonSerializer.Deserialize<int>(userData[progressionFactionKey].Value);
+        var blueprintsData = _titleDataService.Find(new List<string>{"Blueprints"});
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(blueprintsData["Blueprints"]);
+
+        var playerBalance = balanceData["SC"];
+        HashSet<string> scrappedItemIds = [];
+        foreach (var itemId in request.IDs) {
+            var inventoryItemIdx = inventory.FindIndex(i => i.ItemId == itemId);
+            if (inventoryItemIdx == -1) {
+                continue;
+            }
+            var inventoryItem = inventory[inventoryItemIdx];
+            var blueprintData = blueprints[inventoryItem.BaseItemId];
+            // TODO: Probably better to decide based on item kind instead
+            if (inventoryItem.Durability == -1) {
+                factionProgression += blueprintData.OverrideScrappingReputation * inventoryItem.Amount;
+                playerBalance += blueprintData.OverrideScrappingReturns * inventoryItem.Amount;
+            } else {
+                // Items that have durability are not stackable so it's always 1 item
+                factionProgression += MapValue.Map(
+                    inventoryItem.Durability,
+                    blueprintData.DurabilityMax, 0,
+                    blueprintData.OverrideScrappingReputation, (int)(blueprintData.OverrideScrappingReputation * blueprintData.DurabilityBrokenScrappingReturnModifier)
+                );
+                playerBalance += MapValue.Map(
+                    inventoryItem.Durability,
+                    blueprintData.DurabilityMax, 0,
+                    blueprintData.OverrideScrappingReturns, (int)(blueprintData.OverrideScrappingReturns * blueprintData.DurabilityBrokenScrappingReturnModifier)
+                );
+            }
+
+            scrappedItemIds.Add(itemId);
+        }
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!scrappedItemIds.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        balanceData["SC"] = playerBalance;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Inventory"] = JsonSerializer.Serialize(newInventory),
+                ["Balance"] = JsonSerializer.Serialize(balanceData),
+                [progressionFactionKey] = JsonSerializer.Serialize(factionProgression),
+            }
+        );
+
+        return new SellItemsClientResponse
+        {
+            UserID = userId,
+            Error = "",
+            ChangedCurrencies = [new FYCurrencyItem {
+                CurrencyName = "SoftCurrency",
+                Amount = playerBalance,
+            }],
+            PlayerFactionProgressionData = new FYPlayerFactionProgressData {
+                FactionID = request.FactionID,
+                CurrentProgression = factionProgression,
+            },
+            ScrappedItemIDs = scrappedItemIds,
+            ChangedItems = [], // TODO: Changed items from InventoryUpdateData
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SendGamesightEvent.cs

@@ -0,0 +1,63 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class UserIdentifiers {
+    [JsonPropertyName("ip")]
+    public string IP {  get; set; }
+
+    [JsonPropertyName("platform")]
+    public string Platform { get; set; }
+
+    [JsonPropertyName("sku")]
+    public string SKU { get; set; }
+
+    [JsonPropertyName("oS")]
+    public string OS { get; set; }
+
+    [JsonPropertyName("resolution")]
+    public string Resolution { get; set; }
+
+    [JsonPropertyName("timezone")]
+    public string Timezone { get; set; }
+
+    [JsonPropertyName("language")]
+    public string Language { get; set; }
+}
+
+public class SendGamesightEventRequest
+{
+    [JsonPropertyName("type")]
+    public string Type { get; set; }
+
+    [JsonPropertyName("revenue_currency")]
+    public string RevenueCurrency { get; set; }
+
+    [JsonPropertyName("revenue_amount")]
+    public int RevenueAmount { get; set; }
+
+    [JsonPropertyName("identifiers")]
+    public UserIdentifiers Identifiers { get; set; }
+}
+
+public class SendGamesightEventResponse
+{
+    // TODO: Unknown structure. Possibly empty response
+}
+
+[CloudScriptFunction("SendGamesightEvent")]
+public class SendGamesightEventFunction : ICloudScriptFunction<SendGamesightEventRequest, SendGamesightEventResponse>
+{
+    private readonly ILogger<SendGamesightEventFunction> _logger;
+
+    public SendGamesightEventFunction(ILogger<SendGamesightEventFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<SendGamesightEventResponse> ExecuteAsync(SendGamesightEventRequest request)
+    {
+        _logger.LogInformation("Processing Gamesight Event");
+
+        return new SendGamesightEventResponse{};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SetActiveGlobalVanity.cs

@@ -0,0 +1,52 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.UserData;
+
+public class FYSetActiveGlobalVanityRequest
+{
+    [JsonPropertyName("activeVanity")]
+    public FYActiveGlobalVanity ActiveVanity { get; set; }
+}
+
+public class FYSetActiveGlobalVanityResponse
+{
+    [JsonPropertyName("activeVanity")]
+    public FYActiveGlobalVanity ActiveVanity { get; set; }
+}
+
+[CloudScriptFunction("SetActiveGlobalVanity")]
+public class SetActiveGlobalVanityFunction : ICloudScriptFunction<FYSetActiveGlobalVanityRequest, FYSetActiveGlobalVanityResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public SetActiveGlobalVanityFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<FYSetActiveGlobalVanityResponse> ExecuteAsync(FYSetActiveGlobalVanityRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        // TODO: Check vanities availability
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{ ["GlobalVanity"] = JsonSerializer.Serialize(request.ActiveVanity) }
+        );
+
+        return new FYSetActiveGlobalVanityResponse
+        {
+            ActiveVanity = request.ActiveVanity,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SetCharacterVanityArchetype.cs

@@ -0,0 +1,66 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYSetActiveCharacterArchetypeRequest
+{
+    [JsonPropertyName("archetypeId")]
+    public string ArcheTypeId { get; set; } // E03_G02
+}
+
+public class FYSetActiveCharacterArchetypeResponse
+{
+    [JsonPropertyName("success")]
+	public bool Success { get; set; }
+    [JsonPropertyName("returnVanity")]
+	public FYCharacterVanity ReturnVanity { get; set; }
+}
+
+[CloudScriptFunction("SetCharacterVanityArchetype")]
+public class SetCharacterVanityArchetype : ICloudScriptFunction<FYSetActiveCharacterArchetypeRequest, FYSetActiveCharacterArchetypeResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public SetCharacterVanityArchetype(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<FYSetActiveCharacterArchetypeResponse> ExecuteAsync(FYSetActiveCharacterArchetypeRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            return new FYSetActiveCharacterArchetypeResponse{};
+        }
+
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(userId, userId, new List<string>{"CharacterVanity"});
+        var returnVanity = JsonSerializer.Deserialize<FYCharacterVanity>(userData["CharacterVanity"].Value);
+
+        // TODO: This works only for Season 2. Season 3 has different IDs
+        var genderSuffix = request.ArcheTypeId.EndsWith("G02") ? "M" : "F";
+        returnVanity.ArchetypeID = request.ArcheTypeId;
+        returnVanity.HeadItem.ID = request.ArcheTypeId + "_Head01";
+        returnVanity.BootsItem.ID = "StarterOutfit01_Boots_" + genderSuffix;
+        returnVanity.ChestItem.ID = "StarterOutfit01_Chest_" + genderSuffix;
+        returnVanity.GloveItem.ID = "StarterOutfit01_Gloves_" + genderSuffix;
+        returnVanity.BaseSuitItem.ID = "StarterOutfit01" + genderSuffix + "_BaseSuit";
+        returnVanity.BodyType = request.ArcheTypeId.EndsWith("G02") ? 1 : 2;
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{ ["CharacterVanity"] = JsonSerializer.Serialize(returnVanity) }
+        );
+
+        return new FYSetActiveCharacterArchetypeResponse
+        {
+            Success = true,
+            ReturnVanity = returnVanity,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SetCharacterVanityItems.cs

@@ -0,0 +1,115 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.CloudScript.Functions;
+using Prospect.Server.Api.Services.UserData;
+
+public class VanityDataiD {
+    [JsonPropertyName("iD")]
+    public string ID { get; set; }
+    [JsonPropertyName("materialIndex")]
+    public int MaterialIndex { get; set; }
+}
+
+public class SetCharacterVanityItems {
+    [JsonPropertyName("userId")]
+    public string UserID { get; set; }
+
+    [JsonPropertyName("head_item")]
+    public VanityDataiD HeadItem { get; set; }
+
+    [JsonPropertyName("boots_item")]
+    public VanityDataiD BootsItem { get; set; }
+    [JsonPropertyName("chest_item")]
+    public VanityDataiD ChestItem { get; set; }
+    [JsonPropertyName("glove_item")]
+    public VanityDataiD GloveItem { get; set; }
+    [JsonPropertyName("base_suit_item")]
+    public VanityDataiD BaseSuitItem { get; set; }
+    [JsonPropertyName("melee_weapon_item")]
+    public VanityDataiD MeleeWeaponItem { get; set; }
+    [JsonPropertyName("body_type")]
+    public int BodyType { get; set; }
+    [JsonPropertyName("archetype_id")]
+    public string ArchetypeID { get; set; }
+    [JsonPropertyName("slot_index")]
+    public int SlotIndex { get; set; }
+}
+
+public class SetCharacterVanityItemsRequest {
+    [JsonPropertyName("desiredVanity")]
+    public SetCharacterVanityItems DesiredVanity { get; set; }
+}
+
+public class SetCharacterVanityItemsResponse
+{
+    [JsonPropertyName("returnVanity")]
+    public FYCharacterVanity ReturnVanity { get; set; }
+}
+
+[CloudScriptFunction("SetCharacterVanityItems")]
+public class SetCharacterVanityItemsFunction : ICloudScriptFunction<SetCharacterVanityItemsRequest, SetCharacterVanityItemsResponse>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+
+    public SetCharacterVanityItemsFunction(IHttpContextAccessor httpContextAccessor, UserDataService userDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+    }
+
+    public async Task<SetCharacterVanityItemsResponse> ExecuteAsync(SetCharacterVanityItemsRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        // TODO: Check for available vanity items
+        // TODO: Refactor
+        var vanityData = request.DesiredVanity;
+        var mappedVanityItems = new FYCharacterVanity{
+            UserID = userId,
+            BaseSuitItem = new FYVanityMaterialItem{
+                ID = vanityData.BaseSuitItem.ID,
+                MaterialIndex = vanityData.BaseSuitItem.MaterialIndex,
+            },
+            BootsItem = new FYVanityMaterialItem{
+                ID = vanityData.BootsItem.ID,
+                MaterialIndex = vanityData.BootsItem.MaterialIndex,
+            },
+            ChestItem = new FYVanityMaterialItem{
+                ID = vanityData.ChestItem.ID,
+                MaterialIndex = vanityData.ChestItem.MaterialIndex,
+            },
+            GloveItem = new FYVanityMaterialItem{
+                ID = vanityData.GloveItem.ID,
+                MaterialIndex = vanityData.GloveItem.MaterialIndex,
+            },
+            HeadItem = new FYVanityMaterialItem{
+                ID = vanityData.HeadItem.ID,
+                MaterialIndex = vanityData.HeadItem.MaterialIndex,
+            },
+            MeleeWeaponItem = new FYVanityMaterialItem{
+                ID = vanityData.MeleeWeaponItem.ID,
+                MaterialIndex = vanityData.MeleeWeaponItem.MaterialIndex,
+            },
+            ArchetypeID = vanityData.ArchetypeID,
+            BodyType = vanityData.BodyType,
+            SlotIndex = vanityData.SlotIndex
+        };
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{ ["CharacterVanity"] = JsonSerializer.Serialize(mappedVanityItems) }
+        );
+
+        return new SetCharacterVanityItemsResponse
+        {
+            ReturnVanity = mappedVanityItems,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SkipItemCraftingClient.cs

@@ -0,0 +1,162 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+using Prospect.Server.Api.Utils;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYSkipItemCraftingClientRequest {
+    [JsonPropertyName("useOptionalCosts")]
+	public bool UseOptionalCosts { get; set; }
+}
+
+public class FYSkipItemCraftingClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("craftedItemData")]
+	public FYCraftedItemData CraftedItemData { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+}
+
+public class FYCraftedItemData
+{
+    [JsonPropertyName("itemsGrantedOrUpdated")]
+	public List<FYCustomItemInfo> ItemsGrantedOrUpdated { get; set; }
+    [JsonPropertyName("BlueprintName")]
+	public string BlueprintName { get; set; }
+};
+
+[CloudScriptFunction("SkipItemCraftingClient")]
+public class SkipItemCraftingClient : ICloudScriptFunction<FYSkipItemCraftingClientRequest, FYSkipItemCraftingClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public SkipItemCraftingClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYSkipItemCraftingClientResult> ExecuteAsync(FYSkipItemCraftingClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var titleData = _titleDataService.Find(new List<string>{"Blueprints"});
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"CraftingTimer__2022_05_12", "Balance", "Inventory"}
+        );
+
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var craftingTimer = JsonSerializer.Deserialize<FYItemCurrentlyBeingCrafted>(userData["CraftingTimer__2022_05_12"].Value);
+
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+
+        var blueprintName = craftingTimer.ItemID;
+        var blueprintData = blueprints[blueprintName];
+
+        // Validate price
+        var shopCraftingData = blueprintData.ItemShopsCraftingData["CraftingStation"];
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var craftEndTime = craftingTimer.UtcTimestampWhenCraftingStarted.Seconds + shopCraftingData.UpgradeTimeSeconds;
+        var craftStartTime = craftingTimer.UtcTimestampWhenCraftingStarted.Seconds;
+        FYCurrencyItem[] changedCurrency;
+        if (request.UseOptionalCosts) {
+            var remaining = MapValue.Map(now, craftStartTime, craftEndTime, shopCraftingData.SkipOptionalCraftingMaxCost, 1);
+            if (balance["SC"] < remaining) {
+                return new FYSkipItemCraftingClientResult {
+                    UserID = userId,
+                    Error = "Insufficient balance",
+                };
+            }
+            balance["SC"] -= remaining;
+            changedCurrency = [new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] }];
+        } else {
+            var remaining = MapValue.Map(now, craftStartTime, craftEndTime, shopCraftingData.SkipCraftingMaxCost, 1);
+            if (balance["AU"] < remaining) {
+                return new FYSkipItemCraftingClientResult {
+                    UserID = userId,
+                    Error = "Insufficient balance",
+                };
+            }
+            balance["AU"] -= remaining;
+            changedCurrency = [new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] }];
+        }
+
+        List<FYCustomItemInfo> itemsGrantedOrUpdated = [];
+        var remainingAmount = blueprintData.AmountPerPurchase;
+        // Populate incomplete stacks first
+        foreach (var item in inventory) {
+            if (item.BaseItemId != blueprintName || item.Amount >= blueprintData.MaxAmountPerStack) {
+                continue;
+            }
+            var remainingSpace = blueprintData.MaxAmountPerStack - item.Amount;
+            var amountToAdd = Math.Min(remainingAmount, remainingSpace);
+            item.Amount += amountToAdd;
+            remainingAmount -= amountToAdd;
+            itemsGrantedOrUpdated.Add(item);
+            if (remainingAmount == 0) {
+                break;
+            }
+        }
+
+        while (remainingAmount > 0) {
+            var itemStackAmount = Math.Min(blueprintData.MaxAmountPerStack, remainingAmount);
+            var craftedItem = new FYCustomItemInfo {
+                ItemId = Guid.NewGuid().ToString(),
+                Amount = itemStackAmount,
+                BaseItemId = blueprintName,
+                Durability = blueprintData.DurabilityMax,
+                Insurance = "",
+                InsuranceOwnerPlayfabId = "",
+                ModData = new FYModItems { M = [] },
+                Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                InsuredAttachmentId = "",
+                PrimaryVanityId = 0,
+                SecondaryVanityId = 0,
+                RolledPerks = [],
+            };
+            inventory.Add(craftedItem);
+            itemsGrantedOrUpdated.Add(craftedItem);
+            remainingAmount -= itemStackAmount;
+        }
+
+        craftingTimer.ItemID = "";
+        craftingTimer.UtcTimestampWhenCraftingStarted.Seconds = 0;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+                ["CraftingTimer__2022_05_12"] = JsonSerializer.Serialize(craftingTimer),
+            }
+        );
+
+        return new FYSkipItemCraftingClientResult
+        {
+            UserID = userId,
+            Error = "",
+            CraftedItemData = new FYCraftedItemData {
+                BlueprintName = blueprintName,
+                ItemsGrantedOrUpdated = itemsGrantedOrUpdated,
+            },
+            ChangedCurrencies = changedCurrency,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SkipPlayerQuarterUpgradeClient.cs

@@ -0,0 +1,128 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+using Prospect.Server.Api.Utils;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYSkipPlayerQuarterUpgradeClientRequest {
+    [JsonPropertyName("useOptionalCosts")]
+	public bool UseOptionalCosts { get; set; }
+}
+
+public class FYSkipPlayerQuarterUpgradeClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("newLevel")]
+	public int NewLevel { get; set; }
+    [JsonPropertyName("upgradeStartedTime")]
+	public FYTimestamp UpgradeStartedTime { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public FYCustomItemInfo[] ChangedItems { get; set; }
+    [JsonPropertyName("deletedItems")]
+	public string[] DeletedItemsIds { get; set; }
+}
+
+[CloudScriptFunction("SkipPlayerQuarterUpgradeClient")]
+public class SkipPlayerQuarterUpgradeClient : ICloudScriptFunction<FYSkipPlayerQuarterUpgradeClientRequest, FYSkipPlayerQuarterUpgradeClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public SkipPlayerQuarterUpgradeClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYSkipPlayerQuarterUpgradeClientResult> ExecuteAsync(FYSkipPlayerQuarterUpgradeClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"PlayerQuartersLevel", "Balance"}
+        );
+
+        var userPlayerQuarters = JsonSerializer.Deserialize<FYPlayerQuarterStatus>(userData["PlayerQuartersLevel"].Value);
+        if (userPlayerQuarters.UpgradeStartedTime.Seconds == 0) {
+            return new FYSkipPlayerQuarterUpgradeClientResult
+            {
+                UserID = userId,
+                Error = "Nothing is being constructed",
+            };
+        }
+
+        var titleData = _titleDataService.Find(new List<string>{"PlayerQuarters"});
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var playerQuartersData = JsonSerializer.Deserialize<TitleDataPlayerQuartersInfo[]>(titleData["PlayerQuarters"]);
+        var nextQuartersLevel = playerQuartersData[userPlayerQuarters.Level - 1]; // Quarters level starts from 1
+
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var craftEndTime = userPlayerQuarters.UpgradeStartedTime.Seconds + nextQuartersLevel.UpgradeSeconds;
+        var craftStartTime = userPlayerQuarters.UpgradeStartedTime.Seconds;
+        FYCurrencyItem[] changedCurrency;
+        if (request.UseOptionalCosts) {
+            var remaining = MapValue.Map(now, craftStartTime, craftEndTime, nextQuartersLevel.OptionalRushCosts, 1);
+            if (balance["SC"] < remaining) {
+                return new FYSkipPlayerQuarterUpgradeClientResult {
+                    UserID = userId,
+                    Error = "Insufficient balance",
+                };
+            }
+            balance["SC"] -= remaining;
+            changedCurrency = [new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] }];
+        } else {
+            var remaining = MapValue.Map(now, craftStartTime, craftEndTime, nextQuartersLevel.InitialRushCosts, 1);
+            if (balance["AU"] < remaining) {
+                return new FYSkipPlayerQuarterUpgradeClientResult {
+                    UserID = userId,
+                    Error = "Insufficient balance",
+                };
+            }
+            balance["AU"] -= remaining;
+            changedCurrency = [new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] }];
+        }
+
+        var upgradeStartedTime = new FYTimestamp {
+            Seconds = 0,
+        };
+        userPlayerQuarters.Level++;
+        userPlayerQuarters.UpgradeStartedTime = upgradeStartedTime;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["PlayerQuartersLevel"] = JsonSerializer.Serialize(userPlayerQuarters),
+            }
+        );
+
+        return new FYSkipPlayerQuarterUpgradeClientResult
+        {
+            UserID = userId,
+            Error = "",
+            NewLevel = userPlayerQuarters.Level,
+            UpgradeStartedTime = upgradeStartedTime,
+            RemainingTimeInSeconds = 0,
+            ChangedItems = [],
+            DeletedItemsIds = [],
+            ChangedCurrencies = changedCurrency,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SkipTechTreeNodeUpgradeClient.cs

@@ -0,0 +1,159 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+using Prospect.Server.Api.Utils;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYSkipTechTreeNodeUpgradeClientRequest {
+    [JsonPropertyName("useOptionalCosts")]
+	public bool UseOptionalCosts { get; set; }
+}
+
+public class FYSkipTechTreeNodeUpgradeClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("upgradedNode")]
+	public FYTechTreeNodeStatus UpgradedNode { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public FYCustomItemInfo[] ChangedItems { get; set; }
+    [JsonPropertyName("deletedItems")]
+	public string[] DeletedItemsIds { get; set; }
+}
+
+[CloudScriptFunction("SkipTechTreeNodeUpgradeClient")]
+public class SkipTechTreeNodeUpgradeClient : ICloudScriptFunction<FYSkipTechTreeNodeUpgradeClientRequest, FYSkipTechTreeNodeUpgradeClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public SkipTechTreeNodeUpgradeClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYSkipTechTreeNodeUpgradeClientResult> ExecuteAsync(FYSkipTechTreeNodeUpgradeClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"TechTreeNodeData", "Balance", "CharacterTechTreeBonuses"}
+        );
+
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var userTechTree = JsonSerializer.Deserialize<UserTechTreeNodeData>(userData["TechTreeNodeData"].Value);
+
+        var currentNode = userTechTree.NodeInProgress;
+        if (currentNode == "") {
+            return new FYSkipTechTreeNodeUpgradeClientResult
+            {
+                UserID = userId,
+                Error = "Nothing is being constructed",
+            };
+        }
+
+        var titleData = _titleDataService.Find(new List<string>{"TechTreeNodes"});
+        var techTreeNodes = JsonSerializer.Deserialize<Dictionary<string, TitleDataTechTreeNodeInfo>>(titleData["TechTreeNodes"]);
+
+        var node = userTechTree.Nodes[currentNode];
+        var nodeInfo = techTreeNodes[currentNode];
+        var nodeLevelInfo = techTreeNodes[currentNode].PerkLevels[node.Level]; // Current node level - next upgradable level due to index offset
+
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var craftEndTime = node.UpgradeStartedTime.Seconds + nodeLevelInfo.UpgradeSeconds;
+        var craftStartTime = node.UpgradeStartedTime.Seconds;
+        FYCurrencyItem[] changedCurrency;
+        if (request.UseOptionalCosts) {
+            var remaining = MapValue.Map(now, craftStartTime, craftEndTime, nodeLevelInfo.OptionalRushCosts, 1);
+            if (balance["SC"] < remaining) {
+                return new FYSkipTechTreeNodeUpgradeClientResult {
+                    UserID = userId,
+                    Error = "Insufficient balance",
+                };
+            }
+            balance["SC"] -= remaining;
+            changedCurrency = [new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] }];
+        } else {
+            var remaining = MapValue.Map(now, craftStartTime, craftEndTime, nodeLevelInfo.InitialRushCosts, 1);
+            if (balance["AU"] < remaining) {
+                return new FYSkipTechTreeNodeUpgradeClientResult {
+                    UserID = userId,
+                    Error = "Insufficient balance",
+                };
+            }
+            balance["AU"] -= remaining;
+            changedCurrency = [new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] }];
+        }
+
+        userTechTree.TotalUpgrades++;
+        userTechTree.NodeInProgress = "";
+        node.Level++;
+        node.UpgradeStartedTime.Seconds = 0;
+
+        var techTreeBonuses = JsonSerializer.Deserialize<CharacterTechTreeBonuses>(userData["CharacterTechTreeBonuses"].Value);
+        switch (nodeInfo.NodePerkType) {
+            case EYTechTreeNodePerkType.DailyCrate:
+                techTreeBonuses.CrateTier += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.IncreaseStashSize:
+                techTreeBonuses.AddStashSize += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.IncreaseBagSize:
+                techTreeBonuses.AddSafePocketSize += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.PassiveKMarkGenHour:
+                techTreeBonuses.KmarksRate += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.IncreasePassiveKMarkGenCap:
+                techTreeBonuses.KmarksCap += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.PassiveAurumGenDay:
+                techTreeBonuses.AurumRate = (float)Math.Round(nodeLevelInfo.PerkAmount + techTreeBonuses.AurumRate, 2);
+                break;
+            case EYTechTreeNodePerkType.IncreasePassiveAurumGenCap:
+                techTreeBonuses.AurumCap += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.ReduceUpgradingTimePerc:
+                techTreeBonuses.UpgradeSpeedFactor = (float)Math.Round(nodeLevelInfo.PerkAmount + techTreeBonuses.UpgradeSpeedFactor, 2);
+                break;
+            default:
+                break;
+        }
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["TechTreeNodeData"] = JsonSerializer.Serialize(userTechTree),
+                ["CharacterTechTreeBonuses"] = JsonSerializer.Serialize(techTreeBonuses),
+            }
+        );
+
+        return new FYSkipTechTreeNodeUpgradeClientResult
+        {
+            UserID = userId,
+            Error = "",
+            UpgradedNode = node,
+            RemainingTimeInSeconds = 0,
+            ChangedItems = [],
+            DeletedItemsIds = [],
+            ChangedCurrencies = changedCurrency,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SquadMemberReadyForMatch.cs

@@ -0,0 +1,70 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Microsoft.AspNetCore.SignalR;
+using Prospect.Server.Api.Hubs;
+
+public class SquadMemberReadyForMatchRequest
+{
+    [JsonPropertyName("squadId")]
+    public string SquadID { get; set; }
+    [JsonPropertyName("matchmakingSettings")]
+	public FYUserMatchmakingSettings matchmakingSettings { get; set; }
+}
+
+public class SquadMemberReadyForMatchResponse
+{
+    [JsonPropertyName("result")]
+	public int Result { get; set; } // EYSquadActionResult
+    [JsonPropertyName("squad")]
+	public FYPlayFabSquad Squad { get; set; }
+    [JsonPropertyName("isSquadReadyForMatch")]
+	public bool IsSquadReadyForMatch { get; set; }
+}
+
+[CloudScriptFunction("SquadMemberReadyForMatch")]
+public class SquadMemberReadyForMatchFunction : ICloudScriptFunction<SquadMemberReadyForMatchRequest, SquadMemberReadyForMatchResponse>
+{
+    private readonly ILogger<SquadMemberReadyForMatchFunction> _logger;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly IHubContext<CycleHub> _hubContext;
+
+    public SquadMemberReadyForMatchFunction(ILogger<SquadMemberReadyForMatchFunction> logger, IHttpContextAccessor httpContextAccessor, IHubContext<CycleHub> hubContext)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _logger = logger;
+        _hubContext = hubContext;
+    }
+
+    public async Task<SquadMemberReadyForMatchResponse> ExecuteAsync(SquadMemberReadyForMatchRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        return new SquadMemberReadyForMatchResponse
+        {
+            Result = 0, // EYSquadActionResult::OK
+            Squad = new FYPlayFabSquad {
+                SquadID = "100", // TODO
+                // Members = [
+                //     new FYPlayFabSquadMember {
+                //         Profile = new FYPlayFabPlayerProfile {
+                //             PlayerId = userId,
+                //         },
+                //         onlineState = 0, // EYUserState::IN_STATION
+                //         matchmakingSettings = new FYUserMatchmakingSettings {
+                //             isReadyForMatch = true,
+                //             isSecretLeader = true,
+                //             selectedMapName = "Map01",
+                //         }
+                //     }
+                // ],
+            },
+            IsSquadReadyForMatch = true,
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SquadMemberSelectedMap.cs

@@ -0,0 +1,31 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+public class SquadMemberSelectedMapRequest
+{
+    [JsonPropertyName("squadId")]
+    public string SquadID { get; set; }
+    [JsonPropertyName("selectedMapName")]
+    public string SelectedMapName { get; set; }
+}
+
+public class SquadMemberSelectedMapResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("SquadMemberSelectedMap")]
+public class SquadMemberSelectedMapFunction : ICloudScriptFunction<SquadMemberSelectedMapRequest, SquadMemberSelectedMapResponse>
+{
+    private readonly ILogger<SquadMemberSelectedMapFunction> _logger;
+
+    public SquadMemberSelectedMapFunction(ILogger<SquadMemberSelectedMapFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<SquadMemberSelectedMapResponse> ExecuteAsync(SquadMemberSelectedMapRequest request)
+    {
+        return new SquadMemberSelectedMapResponse
+        {};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/SquadMemberStartingDeployFlow.cs

@@ -0,0 +1,29 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+public class SquadMemberStartingDeployFlowRequest
+{
+    [JsonPropertyName("squadId")]
+    public string SquadID { get; set; }
+}
+
+public class SquadMemberStartingDeployFlowResponse
+{
+    // TODO: Unknown structure
+}
+
+[CloudScriptFunction("SquadMemberStartingDeployFlow")]
+public class SquadMemberStartingDeployFlowFunction : ICloudScriptFunction<SquadMemberStartingDeployFlowRequest, SquadMemberStartingDeployFlowResponse>
+{
+    private readonly ILogger<SquadMemberStartingDeployFlowFunction> _logger;
+
+    public SquadMemberStartingDeployFlowFunction(ILogger<SquadMemberStartingDeployFlowFunction> logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task<SquadMemberStartingDeployFlowResponse> ExecuteAsync(SquadMemberStartingDeployFlowRequest request)
+    {
+        return new SquadMemberStartingDeployFlowResponse
+        {};
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/StartItemCraftingClient.cs

@@ -0,0 +1,155 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYStartItemCraftingClientRequest {
+    [JsonPropertyName("baseItemId")]
+	public string BaseItemID { get; set; }
+}
+
+public class FYStartItemCraftingClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public List<FYCustomItemInfo> ChangedItems { get; set; }
+    [JsonPropertyName("deletedItemsIds")]
+	public HashSet<string> DeletedItemsIds { get; set; }
+}
+
+public class FYItemCurrentlyBeingCrafted {
+    [JsonPropertyName("itemId")]
+	public string ItemID { get; set; }
+    [JsonPropertyName("utcTimestampWhenCraftingStarted")]
+	public FYTimestamp UtcTimestampWhenCraftingStarted { get; set; }
+}
+
+[CloudScriptFunction("StartItemCraftingClient")]
+public class StartItemCraftingClient : ICloudScriptFunction<FYStartItemCraftingClientRequest, FYStartItemCraftingClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public StartItemCraftingClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYStartItemCraftingClientResult> ExecuteAsync(FYStartItemCraftingClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var titleData = _titleDataService.Find(new List<string>{"Blueprints"});
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"CraftingTimer__2022_05_12", "Balance", "Inventory"}
+        );
+
+        var craftingTimer = JsonSerializer.Deserialize<FYItemCurrentlyBeingCrafted>(userData["CraftingTimer__2022_05_12"].Value);
+        if (craftingTimer.UtcTimestampWhenCraftingStarted.Seconds != 0) {
+            return new FYStartItemCraftingClientResult
+            {
+                UserID = userId,
+                Error = "Crafting is in progress",
+            };
+        }
+
+        // TODO: Contract unlock criteria
+
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+
+        var blueprintData = blueprints[request.BaseItemID];
+
+        // Validate price
+        var shopCraftingData = blueprintData.ItemShopsCraftingData["CraftingStation"];
+        // TODO: Refactor
+        List<FYCustomItemInfo> changedItems = [];
+        HashSet<string> deletedItemsIds = [];
+        List<FYCurrencyItem> changedCurrencies = [];
+        foreach (var ingredient in shopCraftingData.ItemRecipeIngredients) {
+            int remaining = ingredient.Amount;
+            if (ingredient.Currency == "SoftCurrency") {
+                remaining -= ingredient.Amount;
+                balance["SC"] -= ingredient.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] });
+            } else if (ingredient.Currency == "Aurum") {
+                remaining -= ingredient.Amount;
+                balance["AU"] -= ingredient.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] });
+            } else {
+                for (var i = 0; i < inventory.Count; i++) {
+                    var item = inventory[i];
+                    if (item.BaseItemId != ingredient.Currency) {
+                        continue;
+                    }
+                    var localRemaining = remaining;
+                    remaining -= item.Amount;
+                    item.Amount -= localRemaining;
+                    if (item.Amount <= 0) {
+                        item.Amount = 0;
+                        deletedItemsIds.Add(item.ItemId);
+                    } else {
+                        changedItems.Add(item);
+                    }
+                    if (remaining <= 0) {
+                        break;
+                    }
+                }
+            }
+            if (remaining > 0) {
+                return new FYStartItemCraftingClientResult
+                {
+                    UserID = userId,
+                    Error = "Missing required items",
+                };
+            }
+        }
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!deletedItemsIds.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        craftingTimer.ItemID = request.BaseItemID;
+        craftingTimer.UtcTimestampWhenCraftingStarted.Seconds = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["Inventory"] = JsonSerializer.Serialize(newInventory),
+                ["CraftingTimer__2022_05_12"] = JsonSerializer.Serialize(craftingTimer),
+            }
+        );
+
+        return new FYStartItemCraftingClientResult
+        {
+            UserID = userId,
+            Error = "",
+            ChangedItems = changedItems,
+            DeletedItemsIds = deletedItemsIds,
+            ChangedCurrencies = changedCurrencies.ToArray(),
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/StartPlayerQuarterUpgradeClient.cs

@@ -0,0 +1,155 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYStartPlayerQuarterUpgradeClientRequest {
+}
+
+public class FYStartPlayerQuarterUpgradeClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("newLevel")]
+	public int NewLevel { get; set; }
+    [JsonPropertyName("upgradeStartedTime")]
+	public FYTimestamp UpgradeStartedTime { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public List<FYCustomItemInfo> ChangedItems { get; set; }
+    [JsonPropertyName("deletedItems")]
+	public HashSet<string> DeletedItemsIds { get; set; }
+}
+
+[CloudScriptFunction("StartPlayerQuarterUpgradeClient")]
+public class StartPlayerQuarterUpgradeClient : ICloudScriptFunction<FYStartPlayerQuarterUpgradeClientRequest, FYStartPlayerQuarterUpgradeClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public StartPlayerQuarterUpgradeClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYStartPlayerQuarterUpgradeClientResult> ExecuteAsync(FYStartPlayerQuarterUpgradeClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"PlayerQuartersLevel", "Balance", "Inventory"}
+        );
+
+        var userPlayerQuarters = JsonSerializer.Deserialize<FYPlayerQuarterStatus>(userData["PlayerQuartersLevel"].Value);
+        if (userPlayerQuarters.UpgradeStartedTime.Seconds != 0) {
+            return new FYStartPlayerQuarterUpgradeClientResult
+            {
+                UserID = userId,
+                Error = "Player quarters upgrade is in progress",
+            };
+        }
+
+        var titleData = _titleDataService.Find(new List<string>{"PlayerQuarters"});
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var playerQuartersData = JsonSerializer.Deserialize<TitleDataPlayerQuartersInfo[]>(titleData["PlayerQuarters"]);
+        // Current level contains the information about next level
+        // Player quarter level starts from 1
+        var nextQuartersLevel = playerQuartersData[userPlayerQuarters.Level - 1];
+
+        // Validate price
+        // TODO: Refactor
+        List<FYCustomItemInfo> changedItems = [];
+        HashSet<string> deletedItemsIds = [];
+        List<FYCurrencyItem> changedCurrencies = [];
+        foreach (var ingredient in nextQuartersLevel.UpgradeCosts) {
+            int remaining = ingredient.Amount;
+            if (ingredient.Currency == "SoftCurrency") {
+                remaining -= ingredient.Amount;
+                balance["SC"] -= ingredient.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] });
+            } else if (ingredient.Currency == "Aurum") {
+                remaining -= ingredient.Amount;
+                balance["AU"] -= ingredient.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] });
+            } else {
+                for (var i = 0; i < inventory.Count; i++) {
+                    var item = inventory[i];
+                    if (item.BaseItemId != ingredient.Currency) {
+                        continue;
+                    }
+                    var localRemaining = remaining;
+                    remaining -= item.Amount;
+                    item.Amount -= localRemaining;
+                    if (item.Amount <= 0) {
+                        item.Amount = 0;
+                        deletedItemsIds.Add(item.ItemId);
+                    } else {
+                        changedItems.Add(item);
+                    }
+                    if (remaining <= 0) {
+                        break;
+                    }
+                }
+            }
+            if (remaining > 0) {
+                return new FYStartPlayerQuarterUpgradeClientResult
+                {
+                    UserID = userId,
+                    Error = "Missing required items",
+                };
+            }
+        }
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!deletedItemsIds.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        var startTime = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var upgradeStartedTime = new FYTimestamp {
+            Seconds = startTime
+        };
+        userPlayerQuarters.UpgradeStartedTime = upgradeStartedTime;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+                ["PlayerQuartersLevel"] = JsonSerializer.Serialize(userPlayerQuarters),
+            }
+        );
+
+        return new FYStartPlayerQuarterUpgradeClientResult
+        {
+            UserID = userId,
+            Error = "",
+            NewLevel = userPlayerQuarters.Level++,
+            UpgradeStartedTime = upgradeStartedTime,
+            RemainingTimeInSeconds = nextQuartersLevel.UpgradeSeconds,
+            ChangedItems = changedItems,
+            DeletedItemsIds = deletedItemsIds,
+            ChangedCurrencies = changedCurrencies.ToArray(),
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/StartTechTreeNodeUpgradeClient.cs

@@ -0,0 +1,167 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYStartTechTreeNodeUpgradeClientRequest {
+    [JsonPropertyName("nodeId")]
+    public string NodeID { get; set; }
+}
+
+public class FYStartTechTreeNodeUpgradeClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("upgradedNode")]
+	public FYTechTreeNodeStatus UpgradedNode { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public List<FYCustomItemInfo> ChangedItems { get; set; }
+    [JsonPropertyName("deletedItems")]
+	public HashSet<string> DeletedItemsIds { get; set; }
+}
+
+[CloudScriptFunction("StartTechTreeNodeUpgradeClient")]
+public class StartTechTreeNodeUpgradeClient : ICloudScriptFunction<FYStartTechTreeNodeUpgradeClientRequest, FYStartTechTreeNodeUpgradeClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public StartTechTreeNodeUpgradeClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYStartTechTreeNodeUpgradeClientResult> ExecuteAsync(FYStartTechTreeNodeUpgradeClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"TechTreeNodeData", "Balance", "Inventory"}
+        );
+
+        var userTechTree = JsonSerializer.Deserialize<UserTechTreeNodeData>(userData["TechTreeNodeData"].Value);
+
+        var currentNode = userTechTree.NodeInProgress;
+        if (currentNode != "") {
+            return new FYStartTechTreeNodeUpgradeClientResult
+            {
+                UserID = userId,
+                Error = $"{currentNode} is in progress",
+            };
+        }
+
+        var balance = JsonSerializer.Deserialize<Dictionary<string, int>>(userData["Balance"].Value);
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+
+        var titleData = _titleDataService.Find(new List<string>{"TechTreeNodes"});
+        var techTreeNodes = JsonSerializer.Deserialize<Dictionary<string, TitleDataTechTreeNodeInfo>>(titleData["TechTreeNodes"]);
+
+        // Current level contains the information about next level
+        var currentLevel = userTechTree.Nodes[request.NodeID].Level;
+        var techTreeNodeData = techTreeNodes[request.NodeID];
+        var nextTreeNodeLevel = techTreeNodeData.PerkLevels[currentLevel]; // Tech tree node levels start from 0
+
+        // TODO: Dependency check
+
+        // Validate price
+        // TODO: Refactor
+        List<FYCustomItemInfo> changedItems = [];
+        HashSet<string> deletedItemsIds = [];
+        List<FYCurrencyItem> changedCurrencies = [];
+        foreach (var ingredient in nextTreeNodeLevel.UpgradeCosts) {
+            int remaining = ingredient.Amount;
+            if (ingredient.Currency == "SoftCurrency") {
+                remaining -= ingredient.Amount;
+                balance["SC"] -= ingredient.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "SoftCurrency", Amount = balance["SC"] });
+            } else if (ingredient.Currency == "Aurum") {
+                remaining -= ingredient.Amount;
+                balance["AU"] -= ingredient.Amount;
+                changedCurrencies.Add(new FYCurrencyItem { CurrencyName = "Aurum", Amount = balance["AU"] });
+            } else {
+                for (var i = 0; i < inventory.Count; i++) {
+                    var item = inventory[i];
+                    if (item.BaseItemId != ingredient.Currency) {
+                        continue;
+                    }
+                    var localRemaining = remaining;
+                    remaining -= item.Amount;
+                    item.Amount -= localRemaining;
+                    if (item.Amount <= 0) {
+                        item.Amount = 0;
+                        deletedItemsIds.Add(item.ItemId);
+                    } else {
+                        changedItems.Add(item);
+                    }
+                    if (remaining <= 0) {
+                        break;
+                    }
+                }
+            }
+            if (remaining > 0) {
+                return new FYStartTechTreeNodeUpgradeClientResult
+                {
+                    UserID = userId,
+                    Error = "Missing required items",
+                };
+            }
+        }
+
+        // TODO: Optimize
+        var newInventory = new List<FYCustomItemInfo>(inventory.Count);
+        foreach (var item in inventory) {
+            if (!deletedItemsIds.Contains(item.ItemId)) {
+                newInventory.Add(item);
+            }
+        }
+
+        var startTime = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        userTechTree.NodeInProgress = request.NodeID;
+        var upgradeStartedTime = new FYTimestamp {
+            Seconds = startTime
+        };
+        var upgradedNode = new FYTechTreeNodeStatus {
+            Level = currentLevel,
+            NodeID = request.NodeID,
+            UpgradeStartedTime = upgradeStartedTime,
+        };
+        userTechTree.Nodes[request.NodeID] = upgradedNode;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Balance"] = JsonSerializer.Serialize(balance),
+                ["Inventory"] = JsonSerializer.Serialize(newInventory),
+                ["TechTreeNodeData"] = JsonSerializer.Serialize(userTechTree),
+            }
+        );
+
+        return new FYStartTechTreeNodeUpgradeClientResult
+        {
+            UserID = userId,
+            Error = "",
+            UpgradedNode = upgradedNode,
+            RemainingTimeInSeconds = nextTreeNodeLevel.UpgradeSeconds,
+            ChangedItems = changedItems,
+            DeletedItemsIds = deletedItemsIds,
+            ChangedCurrencies = changedCurrencies.ToArray(),
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/StopItemCraftingClient.cs

@@ -0,0 +1,129 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYStopItemCraftingClientRequest {
+    [JsonPropertyName("useOptionalCosts")]
+	public bool UseOptionalCosts { get; set; }
+}
+
+public class FYStopItemCraftingClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("craftedItemData")]
+	public FYCraftedItemData CraftedItemData { get; set; }
+}
+
+[CloudScriptFunction("StopItemCraftingClient")]
+public class StopItemCraftingClient : ICloudScriptFunction<FYStopItemCraftingClientRequest, FYStopItemCraftingClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public StopItemCraftingClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYStopItemCraftingClientResult> ExecuteAsync(FYStopItemCraftingClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var titleData = _titleDataService.Find(new List<string>{"Blueprints"});
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"CraftingTimer__2022_05_12", "Balance", "Inventory"}
+        );
+
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var craftingTimer = JsonSerializer.Deserialize<FYItemCurrentlyBeingCrafted>(userData["CraftingTimer__2022_05_12"].Value);
+
+        var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+
+        var blueprintName = craftingTimer.ItemID;
+        var blueprintData = blueprints[blueprintName];
+        var shopCraftingData = blueprintData.ItemShopsCraftingData["CraftingStation"];
+
+        var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var craftEndTime = craftingTimer.UtcTimestampWhenCraftingStarted.Seconds + shopCraftingData.UpgradeTimeSeconds;
+        if (now < craftEndTime) {
+            return new FYStopItemCraftingClientResult
+            {
+                UserID = userId,
+                Error = "Required amount of time hasn't passed yet",
+            };
+        }
+
+        List<FYCustomItemInfo> itemsGrantedOrUpdated = [];
+        var remainingAmount = blueprintData.AmountPerPurchase;
+        // Populate incomplete stacks first
+        foreach (var item in inventory) {
+            if (item.BaseItemId != blueprintName || item.Amount >= blueprintData.MaxAmountPerStack) {
+                continue;
+            }
+            var remainingSpace = blueprintData.MaxAmountPerStack - item.Amount;
+            var amountToAdd = Math.Min(remainingAmount, remainingSpace);
+            item.Amount += amountToAdd;
+            remainingAmount -= amountToAdd;
+            itemsGrantedOrUpdated.Add(item);
+            if (remainingAmount == 0) {
+                break;
+            }
+        }
+
+        while (remainingAmount > 0) {
+            var itemStackAmount = Math.Min(blueprintData.MaxAmountPerStack, remainingAmount);
+            var craftedItem = new FYCustomItemInfo {
+                ItemId = Guid.NewGuid().ToString(),
+                Amount = itemStackAmount,
+                BaseItemId = blueprintName,
+                Durability = blueprintData.DurabilityMax,
+                Insurance = "",
+                InsuranceOwnerPlayfabId = "",
+                ModData = new FYModItems { M = [] },
+                Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                InsuredAttachmentId = "",
+                PrimaryVanityId = 0,
+                SecondaryVanityId = 0,
+                RolledPerks = [],
+            };
+            inventory.Add(craftedItem);
+            itemsGrantedOrUpdated.Add(craftedItem);
+            remainingAmount -= itemStackAmount;
+        }
+
+        craftingTimer.ItemID = "";
+        craftingTimer.UtcTimestampWhenCraftingStarted.Seconds = 0;
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+                ["CraftingTimer__2022_05_12"] = JsonSerializer.Serialize(craftingTimer),
+            }
+        );
+
+        return new FYStopItemCraftingClientResult
+        {
+            UserID = userId,
+            Error = "",
+            CraftedItemData = new FYCraftedItemData {
+                BlueprintName = blueprintName,
+                ItemsGrantedOrUpdated = itemsGrantedOrUpdated,
+            }
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/TechTreeNodeUpgradePurchaseClient.cs

@@ -0,0 +1,153 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.Auth.Extensions;
+using Prospect.Server.Api.Services.UserData;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYTechTreeNodeUpgradePurchaseClientRequest {
+    // Empty request
+}
+
+public class FYTechTreeNodeUpgradePurchaseClientResult {
+    [JsonPropertyName("userId")]
+	public string UserID { get; set; }
+    [JsonPropertyName("error")]
+	public string Error { get; set; }
+    [JsonPropertyName("upgradedNode")]
+	public FYTechTreeNodeStatus UpgradedNode { get; set; }
+    [JsonPropertyName("remainingTimeInSeconds")]
+	public int RemainingTimeInSeconds { get; set; }
+    [JsonPropertyName("changedCurrencies")]
+	public FYCurrencyItem[] ChangedCurrencies { get; set; }
+    [JsonPropertyName("changedItems")]
+	public FYCustomItemInfo[] ChangedItems { get; set; }
+    [JsonPropertyName("deletedItems")]
+	public string[] DeletedItemsIds { get; set; }
+}
+
+public enum EYTechTreeNodePerkType {
+    None,
+    IncreaseStashSize,
+    IncreaseBagSize,
+    PassiveKMarkGenHour,
+    PassiveAurumGenDay,
+    IncreasePassiveKMarkGenCap,
+    IncreasePassiveAurumGenCap,
+    DailyCrate,
+    ReduceUpgradingTimePerc,
+    MAX
+}
+
+[CloudScriptFunction("TechTreeNodeUpgradePurchaseClient")]
+public class TechTreeNodeUpgradePurchaseClient : ICloudScriptFunction<FYTechTreeNodeUpgradePurchaseClientRequest, FYTechTreeNodeUpgradePurchaseClientResult>
+{
+    private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
+
+    public TechTreeNodeUpgradePurchaseClient(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
+    }
+
+    public async Task<FYTechTreeNodeUpgradePurchaseClientResult> ExecuteAsync(FYTechTreeNodeUpgradePurchaseClientRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"TechTreeNodeData", "CharacterTechTreeBonuses"}
+        );
+
+        var userTechTree = JsonSerializer.Deserialize<UserTechTreeNodeData>(userData["TechTreeNodeData"].Value);
+
+        var currentNode = userTechTree.NodeInProgress;
+        if (currentNode == "") {
+            return new FYTechTreeNodeUpgradePurchaseClientResult
+            {
+                UserID = userId,
+                Error = "Nothing is being constructed",
+            };
+        }
+
+        var titleData = _titleDataService.Find(new List<string>{"TechTreeNodes"});
+        var techTreeNodes = JsonSerializer.Deserialize<Dictionary<string, TitleDataTechTreeNodeInfo>>(titleData["TechTreeNodes"]);
+
+        var node = userTechTree.Nodes[currentNode];
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+
+        var nodeInfo = techTreeNodes[currentNode];
+        var nodeLevelInfo = techTreeNodes[currentNode].PerkLevels[node.Level];
+        var endTime = nodeLevelInfo.UpgradeSeconds + node.UpgradeStartedTime.Seconds;
+        if (now < endTime) {
+            return new FYTechTreeNodeUpgradePurchaseClientResult
+            {
+                UserID = userId,
+                Error = "Upgrade is in progress",
+            };
+        }
+
+        // TODO: Refactor
+        userTechTree.TotalUpgrades++;
+        userTechTree.NodeInProgress = "";
+        node.Level++;
+        node.UpgradeStartedTime.Seconds = 0;
+
+        var techTreeBonuses = JsonSerializer.Deserialize<CharacterTechTreeBonuses>(userData["CharacterTechTreeBonuses"].Value);
+        switch (nodeInfo.NodePerkType) {
+            case EYTechTreeNodePerkType.DailyCrate:
+                techTreeBonuses.CrateTier += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.IncreaseStashSize:
+                techTreeBonuses.AddStashSize += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.IncreaseBagSize:
+                techTreeBonuses.AddSafePocketSize += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.PassiveKMarkGenHour:
+                techTreeBonuses.KmarksRate += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.IncreasePassiveKMarkGenCap:
+                techTreeBonuses.KmarksCap += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.PassiveAurumGenDay:
+                techTreeBonuses.AurumRate = (float)Math.Round(nodeLevelInfo.PerkAmount + techTreeBonuses.AurumRate, 2);
+                break;
+            case EYTechTreeNodePerkType.IncreasePassiveAurumGenCap:
+                techTreeBonuses.AurumCap += (int)nodeLevelInfo.PerkAmount;
+                break;
+            case EYTechTreeNodePerkType.ReduceUpgradingTimePerc:
+                techTreeBonuses.UpgradeSpeedFactor = (float)Math.Round(nodeLevelInfo.PerkAmount + techTreeBonuses.UpgradeSpeedFactor, 2);
+                break;
+            default:
+                break;
+        }
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["TechTreeNodeData"] = JsonSerializer.Serialize(userTechTree),
+                ["CharacterTechTreeBonuses"] = JsonSerializer.Serialize(techTreeBonuses),
+            }
+        );
+
+        return new FYTechTreeNodeUpgradePurchaseClientResult
+        {
+            UserID = userId,
+            Error = "",
+            UpgradedNode = node,
+            RemainingTimeInSeconds = 0,
+            ChangedItems = [],
+            DeletedItemsIds = [],
+            ChangedCurrencies = [],
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/TryGetCompleteSquadInfo.cs

@@ -0,0 +1,76 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript;
+
+public class TryGetCompleteSquadInfoRequest
+{
+    // Empty request
+}
+
+public class FYPlayFabSquad
+{
+    [JsonPropertyName("squadId")]
+    public string SquadID { get; set; }
+    [JsonPropertyName("members")]
+    public FYPlayFabSquadMember[] Members { get; set; }
+}
+
+public class FYPlayFabSquadMember {
+    [JsonPropertyName("profile")]
+	public FYPlayFabPlayerProfile Profile { get; set; }
+    [JsonPropertyName("onlineState")]
+	public int onlineState { get; set; }
+    [JsonPropertyName("matchmakingSettings")]
+	public FYUserMatchmakingSettings matchmakingSettings { get; set; }
+    [JsonPropertyName("mapRowNamesUnlocked")]
+	public string[] mapRowNamesUnlocked { get; set; }
+};
+
+public class FYPlayFabPlayerProfile {
+    [JsonPropertyName("avatarUrl")]
+	public string AvatarUrl { get; set; }
+    [JsonPropertyName("displayName")]
+	public string DisplayName { get; set; }
+    [JsonPropertyName("playerId")]
+	public string PlayerId { get; set; }
+};
+
+public class FYUserMatchmakingSettings {
+    [JsonPropertyName("isReadyForMatch")]
+	public bool isReadyForMatch;
+    [JsonPropertyName("selectedMapName")]
+	public string selectedMapName;
+    [JsonPropertyName("isSecretLeader")]
+	public bool isSecretLeader;
+    [JsonPropertyName("purchaseInsuranceRequest")]
+	public object purchaseInsuranceRequest; // FYPurchaseInsuranceRequest
+};
+
+
+[CloudScriptFunction("TryGetCompleteSquadInfo")]
+public class TryGetCompleteSquadInfoFunction : ICloudScriptFunction<TryGetCompleteSquadInfoRequest, FYPlayFabSquad>
+{
+    private readonly ILogger<TryGetCompleteSquadInfoFunction> _logger;
+    private readonly IHttpContextAccessor _httpContextAccessor;
+
+    public TryGetCompleteSquadInfoFunction(ILogger<TryGetCompleteSquadInfoFunction> logger, IHttpContextAccessor httpContextAccessor)
+    {
+        _httpContextAccessor = httpContextAccessor;
+        _logger = logger;
+    }
+
+    public async Task<FYPlayFabSquad> ExecuteAsync(TryGetCompleteSquadInfoRequest request)
+    {
+        var context = _httpContextAccessor.HttpContext;
+        if (context == null)
+        {
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        // var userId = context.User.FindAuthUserId();
+
+        return new FYPlayFabSquad
+        {
+            // SquadID = "100",
+            // Members = [],
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/UpdateRetentionBonus.cs

@@ -1,38 +1,103 @@
-using Prospect.Server.Api.Services.Auth.Extensions;
+using System.Text.Json;
+using Prospect.Server.Api.Services.Auth.Extensions;
 using Prospect.Server.Api.Services.CloudScript.Models;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+using Prospect.Server.Api.Services.UserData;
 
 namespace Prospect.Server.Api.Services.CloudScript.Functions;
 
 [CloudScriptFunction("UpdateRetentionBonus")]
-public class UpdateRetentionBonus : ICloudScriptFunction<FYRetentionBonusRequest, object?>
+public class UpdateRetentionBonus : ICloudScriptFunction<FYRetentionBonusRequest, FYRetentionBonusResult>
 {
     private readonly IHttpContextAccessor _httpContextAccessor;
+    private readonly UserDataService _userDataService;
+    private readonly TitleDataService _titleDataService;
 
-    public UpdateRetentionBonus(IHttpContextAccessor httpContextAccessor)
+    public UpdateRetentionBonus(IHttpContextAccessor httpContextAccessor, UserDataService userDataService, TitleDataService titleDataService)
     {
         _httpContextAccessor = httpContextAccessor;
+        _userDataService = userDataService;
+        _titleDataService = titleDataService;
     }
 
-    public Task<object?> ExecuteAsync(FYRetentionBonusRequest request)
+    public async Task<FYRetentionBonusResult> ExecuteAsync(FYRetentionBonusRequest request)
     {
         var context = _httpContextAccessor.HttpContext;
         if (context == null)
         {
-            return Task.FromResult<object?>(null);
+            throw new CloudScriptException("CloudScript was not called within a http request");
+        }
+        var userId = context.User.FindAuthUserId();
+        var userData = await _userDataService.FindAsync(
+            userId, userId,
+            new List<string>{"RetentionBonus", "Inventory"}
+        );
+
+        var retentionBonus = JsonSerializer.Deserialize<FYRetentionProgress>(userData["RetentionBonus"].Value);
+        if (retentionBonus.ClaimedAll) {
+            return new FYRetentionBonusResult
+            {
+                UserId = userId,
+                Error = "",
+                PlayerData = retentionBonus,
+            };
         }
 
-        return Task.FromResult<object?>(new
-        {
-            playerData = new
+        var now = (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
+        var nextClaimTime = retentionBonus.LastClaimTime.Seconds + 60 * 60 * 24 * 2;
+        if (now < nextClaimTime) {
+            return new FYRetentionBonusResult
             {
-                daysClaimed = 0,
-                lastClaimTime = new
-                {
-                    seconds = 1635033600
-                }
-            },
-            userId = context.User.FindAuthUserId(),
-            error = (object?)null
-        });
+                UserId = userId,
+                Error = "",
+                PlayerData = retentionBonus,
+            };
+        }
+
+        var titleData = _titleDataService.Find(new List<string>{"Blueprints", "RetentionBonusData"});
+        var bonusData = JsonSerializer.Deserialize<Dictionary<string, TitleDataRetentionBonusInfo>>(titleData["RetentionBonusData"]);
+
+        retentionBonus.DaysClaimed++;
+        retentionBonus.LastClaimTime.Seconds = now;
+        retentionBonus.ClaimedAll = retentionBonus.DaysClaimed >= 14;
+
+        // TODO: Currently only CB2 bonuses are considered
+        var bonuses = bonusData["CB2"];
+        var inventory = JsonSerializer.Deserialize<List<FYCustomItemInfo>>(userData["Inventory"].Value);
+        var rewardItemID = bonuses.Rewards[retentionBonus.DaysClaimed - 1];
+        if (rewardItemID != "None") {
+            var blueprints = JsonSerializer.Deserialize<Dictionary<string, TitleDataBlueprintInfo>>(titleData["Blueprints"]);
+            var itemInfo = blueprints[rewardItemID];
+            inventory.Add(new FYCustomItemInfo{
+                ItemId = Guid.NewGuid().ToString(),
+                Amount = 1,
+                BaseItemId = rewardItemID,
+                Durability = itemInfo.DurabilityMax,
+                Insurance = "",
+                InsuranceOwnerPlayfabId = "",
+                ModData = new FYModItems { M = [] },
+                Origin = new FYItemOriginBackend { G = "", P = "", T = "" },
+                InsuredAttachmentId = "",
+                PrimaryVanityId = 0,
+                SecondaryVanityId = 0,
+                RolledPerks = [],
+            });
+        }
+
+        await _userDataService.UpdateAsync(
+            userId, userId,
+            new Dictionary<string, string>{
+                ["RetentionBonus"] = JsonSerializer.Serialize(retentionBonus),
+                ["Inventory"] = JsonSerializer.Serialize(inventory),
+            }
+        );
+
+        // TODO: This request does not update inventory items. Maybe a SignalR event must be sent?
+        return new FYRetentionBonusResult
+        {
+            UserId = userId,
+            Error = "",
+            PlayerData = retentionBonus,
+        };
     }
 }

src/Prospect.Server.Api/Services/CloudScript/Functions/VivoxJoin.cs

@@ -0,0 +1,63 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript.Models;
+
+namespace Prospect.Server.Api.Services.CloudScript.Functions;
+
+public class FYVivoxJoinTokenRequest
+{
+    [JsonPropertyName("userName")]
+    public string Username { get; set; }
+
+    [JsonPropertyName("channel")]
+    public string Channel { get; set; }
+
+    [JsonPropertyName("hasText")]
+    public bool HasText { get; set; }
+
+    [JsonPropertyName("hasAudio")]
+    public bool HasAudio { get; set; }
+
+    [JsonPropertyName("channelType")]
+    public string ChannelType { get; set; }
+
+    [JsonPropertyName("channelId")]
+    public string ChannelID { get; set; }
+}
+
+[CloudScriptFunction("VivoxJoin")]
+public class VivoxJoin : ICloudScriptFunction<FYVivoxJoinTokenRequest, object>
+{
+    private int ReturnChannelType(string type) {
+        switch (type) {
+            case "GLOBAL": return 2;
+            case "WHISPER": return 3;
+            case "SQUAD": return 4;
+            case "TEAM": return 5;
+            case "MATCH": return 6;
+            default: return 2;
+        }
+    }
+
+    public async Task<object> ExecuteAsync(FYVivoxJoinTokenRequest request)
+    {
+        var exp = (int)DateTimeOffset.UtcNow.AddDays(1).ToUnixTimeSeconds();
+        // TODO: Replace with app configuration
+        var token = TokenGenerator.vxGenerateToken("key", "issuer", exp, "join", request.Username, request.Channel);
+
+        return new FYVivoxJoinData
+        {
+            Request = new Models.Data.FYVivoxJoinTokenRequest{
+                Username = request.Username,
+                // TODO: Client requests sip:confctl-d-issuer._MATCH!p-6000-2000-1.000-2@mtu1xp.vivox.com, but session ID contains
+                // sip:confctl-d-issuer._MATCH!p-6000-2000-1.000-1@mtu1xp.vivox.com.
+                // Server session need to report Vivox channel ID? Or need to construct proper session ID?
+                Channel = request.Channel,
+                HasAudio = request.HasAudio,
+                HasText = request.HasText,
+                ChannelType = ReturnChannelType(request.ChannelType),
+                ChannelID = request.ChannelID,
+            },
+            Token = token
+        };
+    }
+}

src/Prospect.Server.Api/Services/CloudScript/Functions/VivoxLogin.cs

@@ -1,15 +1,107 @@
 using Prospect.Server.Api.Services.CloudScript.Models;
+using System.Security.Cryptography;
+using System.Text.Json;
 
 namespace Prospect.Server.Api.Services.CloudScript.Functions;
 
+public class TokenGenerator
+{
+    public static int TokenSequenceId = 0;
+    // Header is static - base64url encoded {}
+    private static readonly string Header = "e30";
+
+    public static string vxGenerateToken(string key, string issuer, int exp, string vxa, string f, string t)
+    {
+        TokenSequenceId++;
+        var claims = new Claims
+        {
+            iss = issuer,
+            exp = exp,
+            vxa = vxa,
+            vxi = TokenSequenceId,
+            f = f,
+            t = t
+        };
+
+        List<string> segments = new List<string>();
+        segments.Add(Header);
+
+        // Encode payload
+        var claimsString = JsonSerializer.Serialize(claims);
+        var encodedClaims = Base64URLEncode(claimsString);
+
+        // Join segments to prepare for signing
+        segments.Add(encodedClaims);
+        string toSign = String.Join(".", segments);
+
+        // Sign token with key and SHA256
+        string sig = SHA256Hash(key, toSign);
+        segments.Add(sig);
+
+        // Join all 3 parts of token with . and return
+        string token = String.Join(".", segments);
+
+        return token;
+    }
+
+    private static string Base64URLEncode(string plainText)
+    {
+        var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
+        // Remove padding at the end
+        var encodedString = Convert.ToBase64String(plainTextBytes).TrimEnd('=');
+        // Substitute URL-safe characters
+        string urlEncoded = encodedString.Replace("+", "-").Replace("/", "_");
+
+        return urlEncoded;
+    }
+
+    private static string SHA256Hash(string secret, string message)
+    {
+        var encoding = new System.Text.ASCIIEncoding();
+        byte[] keyByte = encoding.GetBytes(secret);
+        byte[] messageBytes = encoding.GetBytes(message);
+        // The instance of HMACSHA256 is constructed and disposed in this method because it is not thread safe
+        using var hmacsha256 = new HMACSHA256(keyByte);
+        byte[] hashmessage = hmacsha256.ComputeHash(messageBytes);
+        var hashString = Convert.ToBase64String(hashmessage).TrimEnd('=');
+        string urlEncoded = hashString.Replace("+", "-").Replace("/", "_");
+
+        return urlEncoded;
+    }
+
+    public class Claims
+    {
+        public string iss { get; set; }
+        public int exp { get; set; }
+        public string vxa { get; set; }
+        public int vxi { get; set; }
+        public string f { get; set; }
+        public string t { get; set; }
+        public string sub { get; set; }
+    }
+}
+
 [CloudScriptFunction("VivoxLogin")]
 public class VivoxLogin : ICloudScriptFunction<FYVivoxLoginTokenRequest, FYVivoxJoinData>
 {
-    public Task<FYVivoxJoinData> ExecuteAsync(FYVivoxLoginTokenRequest request)
+    public async Task<FYVivoxJoinData> ExecuteAsync(FYVivoxLoginTokenRequest request)
     {
-        return Task.FromResult(new FYVivoxJoinData
+        // TODO: Replace with app configuration
+        var channel = "sip:confctl-g-<issuer>.testchannel@mtu1xp.vivox.com"; // e - echo channel, g - global, p - positional
+        var exp = (int)DateTimeOffset.UtcNow.AddSeconds(90).ToUnixTimeSeconds();
+        var token = TokenGenerator.vxGenerateToken("key", "issuer", exp, "login", request.Username, channel);
+
+        return new FYVivoxJoinData
         {
-            
-        });
+            Request = new Models.Data.FYVivoxJoinTokenRequest{
+                Username = request.Username,
+                Channel = channel,
+                HasAudio = false,
+                HasText = true,
+                ChannelType = 2,
+                ChannelID = "testchannel",
+            },
+            Token = token
+        };
     }
 }

src/Prospect.Server.Api/Services/CloudScript/Functions/VivoxSettings.cs

@@ -9,7 +9,10 @@ public class VivoxSettings : ICloudScriptFunction<FYEmptyRequest, FYVivoxSetting
     {
         return Task.FromResult(new FYVivoxSettingsData
         {
-            
+            // TODO: Replace with app configuration
+            // VivoxDomain = "",
+            // VivoxIssuer = "",
+            // VivoxServer = ""
         });
     }
 }

src/Prospect.Server.Api/Services/CloudScript/Models/Data/FYActiveContractPlayerData.cs

@@ -4,9 +4,9 @@ namespace Prospect.Server.Api.Services.CloudScript.Models.Data;
 
 public class FYActiveContractPlayerData
 {
-    [JsonPropertyName("contractId")] 
-    public string ContractId { get; set; } = null!;
+    [JsonPropertyName("contractId")]
+    public string ContractID { get; set; } = null!;
 
     [JsonPropertyName("progress")]
-    public List<int> Progress { get; set; } = null!;
+    public int[] Progress { get; set; } = null!;
 }

src/Prospect.Server.Api/Services/CloudScript/Models/Data/FYFactionContractData.cs

@@ -6,7 +6,4 @@ public class FYFactionContractData
 {
     [JsonPropertyName("contractId")]
     public string ContractId { get; set; } = null!;
-
-    [JsonPropertyName("contractIsLockedDueToLowFactionReputation")]
-    public bool ContractIsLockedDueToLowFactionReputation { get; set; }
 }

src/Prospect.Server.Api/Services/CloudScript/Models/Data/FYTechTreeNodeStatus.cs

@@ -0,0 +1,11 @@
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+
+public class FYTechTreeNodeStatus {
+    [JsonPropertyName("nodeId")]
+	public string NodeID { get; set; }
+    [JsonPropertyName("level")]
+	public int Level { get; set; }
+    [JsonPropertyName("upgradeStartedTime")]
+	public FYTimestamp UpgradeStartedTime { get; set; }
+};

src/Prospect.Server.Api/Services/CloudScript/Models/Data/FYVivoxJoinTokenRequest.cs

@@ -5,14 +5,20 @@ namespace Prospect.Server.Api.Services.CloudScript.Models.Data;
 public class FYVivoxJoinTokenRequest
 {
     [JsonPropertyName("userName")]
-    public string? Username { get; set; }
-    
+    public string Username { get; set; }
+
     [JsonPropertyName("channel")]
-    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
-    public string? Channel { get; set; }
-    
-    // TODO: channelType
-    // TODO: hasText
-    // TODO: hasAudio
-    // TODO: channelId
+    public string Channel { get; set; }
+
+    [JsonPropertyName("hasText")]
+    public bool HasText { get; set; }
+
+    [JsonPropertyName("hasAudio")]
+    public bool HasAudio { get; set; }
+
+    [JsonPropertyName("channelType")]
+    public int ChannelType { get; set; }
+
+    [JsonPropertyName("channelId")]
+    public string ChannelID { get; set; }
 }

src/Prospect.Server.Api/Services/CloudScript/Models/FYEnterMatchAzureFunction.cs

@@ -7,22 +7,25 @@ public class FYEnterMatchAzureFunction
 {
     [JsonPropertyName("optimalRegion")]
     public string? OptimalRegion { get; set; }
-    
+
     [JsonPropertyName("isMatch")]
     public bool IsMatch { get; set; }
-    
+
     [JsonPropertyName("bypassMaintenanceMode")]
     public bool BypassMaintenanceMode { get; set; }
-    
+
     [JsonPropertyName("debugOption")]
     public string? DebugOption { get; set; }
-    
+
     [JsonPropertyName("mapName")]
     public string? MapName { get; set; }
-    
+
     [JsonPropertyName("squad_id")]
     public string? SquadId { get; set; }
-    
-    [JsonPropertyName("purchaseInventoryInsurances")]
-    public List<FYPurchaseInventoryInsuranceRequest>? PurchaseInventoryInsurances { get; set; }
-}
+
+    [JsonPropertyName("purchaseInsuranceRequest")]
+    public FYPurchaseInventoryInsuranceRequest PurchaseInventoryInsurances { get; set; }
+
+    [JsonPropertyName("loginNonce")]
+    public string LoginNonce { get; set; }
+}

src/Prospect.Server.Api/Services/CloudScript/Models/FYEnterMatchAzureFunctionResult.cs

@@ -2,29 +2,22 @@
 
 namespace Prospect.Server.Api.Services.CloudScript.Models;
 
-public class FYEnterMatchAzureFunctionResult
+public class FYEnterMatchmakingResult
 {
     [JsonPropertyName("success")]
     public bool Success { get; set; }
-    
-    [JsonPropertyName("address")]
-    public string? Address { get; set; }
-    
-    [JsonPropertyName("errorMessage")]
-    public string? ErrorMessage { get; set; }
-    
-    [JsonPropertyName("port")]
-    public int Port { get; set; }
-    
-    [JsonPropertyName("sharedIndex")]
-    public int ShardIndex { get; set; }
-    
+    [JsonPropertyName("maintenanceMode")] // TODO: Legacy param?
+    public bool MaintenanceMode { get; set; }
+    [JsonPropertyName("blocker")]
+	public int Blocker { get; set; } // EYMatchmakingBlocker
+    [JsonPropertyName("isMatchTravel")]
+	public bool IsMatchTravel { get; set; }
     [JsonPropertyName("singleplayerStation")]
     public bool SingleplayerStation { get; set; }
-    
-    [JsonPropertyName("maintenanceMode")]
-    public bool MaintenanceMode { get; set; }
-    
-    [JsonPropertyName("sessionTimeJoinDelay")]
-    public float SessionTimeJoinDelay { get; set; }
+    [JsonPropertyName("numAttempts")]
+	public int NumAttempts { get; set; }
+    [JsonPropertyName("sessionId")]
+	public string SessionId { get; set; }
+    [JsonPropertyName("errorMessage")]
+	public string ErrorMessage { get; set; }
 }

src/Prospect.Server.Api/Services/CloudScript/Models/FYRetentionBonusRequest.cs

@@ -1,6 +1,30 @@
-namespace Prospect.Server.Api.Services.CloudScript.Models;
+using System;
+using System.Text.Json.Serialization;
+using Prospect.Server.Api.Services.CloudScript.Models.Data;
+
+namespace Prospect.Server.Api.Services.CloudScript.Models;
 
 public class FYRetentionBonusRequest
 {
     
-}
+}
+
+public class FYRetentionBonusResult
+{
+    [JsonPropertyName("userId")]
+    public string UserId { get; set; }
+    [JsonPropertyName("error")]
+    public string Error { get; set; }
+    [JsonPropertyName("playerData")]
+    public FYRetentionProgress PlayerData { get; set; }
+};
+
+public class FYRetentionProgress
+{
+    [JsonPropertyName("daysClaimed")]
+    public int DaysClaimed { get; set; }
+    [JsonPropertyName("lastClaimTime")]
+    public FYTimestamp LastClaimTime { get; set; }
+    [JsonPropertyName("claimedAll")]
+    public bool ClaimedAll { get; set; }
+};

src/Prospect.Server.Api/Services/CloudScript/Models/FYVivoxJoinData.cs

@@ -8,7 +8,7 @@ public class FYVivoxJoinData
     [JsonPropertyName("request")]
     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
     public FYVivoxJoinTokenRequest? Request { get; set; }
-    
+
     [JsonPropertyName("token")]
     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
     public string? Token { get; set; }