Build an economic system with ZEPETO Product

this._multiplay.Room.AddMessageHandler<InventorySync>("SyncInventories", (message) => {
  this.OpenInformation(`${message.productId} has been ${InventoryAction[message.inventoryAction]} in the inventory.`);
  // Item use sample
  if(message.inventoryAction == InventoryAction.Used){
    if(message.productId == "potion1"){
      console.log("potion use!");
    }
  }
});

this._multiplay.Room.AddMessageHandler<InventorySync>("SyncInventories", (message) => {
  this.OpenInformation(`${message.productId} has been ${InventoryAction[message.inventoryAction]} in the inventory.`);
  // Item use sample
  if(message.inventoryAction == InventoryAction.Used){
    if(message.productId == "potion2"){
      console.log("potion2 use!");
    }
  }
});

import { ZepetoScriptBehaviour } from 'ZEPETO.Script';
import { Text, Button, InputField, Slider } from 'UnityEngine.UI';
import { Object, WaitForSeconds, WaitUntil } from 'UnityEngine';
import { InventoryService } from "ZEPETO.Inventory";
import { BalanceListResponse, CurrencyService, CurrencyError } from "ZEPETO.Currency";
import { ProductRecord, ProductService } from "ZEPETO.Product";
import { ZepetoWorldMultiplay } from "ZEPETO.World";
import { RoomData, Room } from "ZEPETO.Multiplay";

export default class UIBalances extends ZepetoScriptBehaviour {
    @SerializeField() private possessionStarTxt : Text;
    @SerializeField() private possessionEnergyTxt : Text;
    @SerializeField() private possessionZemTxt : Text;
    @SerializeField() private possessionExpTxt : Text;
    @SerializeField() private possessionAmountExpTxt : Text;
    @SerializeField() private possessionLevelTxt : Text;
    @SerializeField() private expSlider : Slider;

    private _multiplay : ZepetoWorldMultiplay;
    private _room : Room;
    private _myExp :number = 0;
    private _amountExp :number = 30;
    private _myLevel:number = 1;    

    private Start() {
        this.RefreshAllBalanceUI();
        this.RefreshExpUI();
        this._multiplay = Object.FindObjectOfType<ZepetoWorldMultiplay>();

        this._multiplay.RoomJoined += (room: Room) => {
            this._room = room;
            this.InitMessageHandler();
        }
    }
    
    private InitMessageHandler() {
        this._room.AddMessageHandler<BalanceSync>("SyncBalances", (message) => {
            this.RefreshAllBalanceUI();
        });
        ProductService.OnPurchaseCompleted.AddListener((product, response) => {
            this.RefreshAllBalanceUI();
        });
    }
    
    private RefreshAllBalanceUI(){
        this.StartCoroutine(this.RefreshBalanceUI());
        this.StartCoroutine(this.RefreshOfficialCurrencyUI());
    }
    
    private *RefreshBalanceUI(){
        const request = CurrencyService.GetUserCurrencyBalancesAsync();
        yield new WaitUntil(() => request.keepWaiting == false);
        if(request.responseData.isSuccess) {
            this.possessionStarTxt.text = request.responseData.currencies?.ContainsKey(Currency.star) ? request.responseData.currencies?.get_Item(Currency.star).toString() :"0";
            this.possessionEnergyTxt.text = request.responseData.currencies?.ContainsKey(Currency.energy) ? request.responseData.currencies?.get_Item(Currency.energy).toString() :"0";
        }
    }
    
    private *RefreshOfficialCurrencyUI(){
        const request = CurrencyService.GetOfficialCurrencyBalanceAsync();
        yield new WaitUntil(() => request.keepWaiting == false);
        this.possessionZemTxt.text = request.responseData.currency.quantity.toString();
    }
    
    public IncreaseExp(quantity:number){
        this._myExp += quantity;
        if(this._myExp >= this._amountExp){
            this._myLevel++;
            this._myExp -= this._amountExp;
            this.LevelUpReward();
        }
        this.RefreshExpUI();
    }
    
    private RefreshExpUI(){
        this.possessionExpTxt.text = this._myExp.toString();
        this.possessionLevelTxt.text = this._myLevel.toString();
        this.expSlider.value = this._myExp / this._amountExp;
    }
    
    private LevelUpReward(){
        // Get 5 stars for every level you raise
        const data = new RoomData();
        data.Add("currencyId", Currency.star);
        data.Add("quantity", 5);
        this._multiplay.Room?.Send("onCredit", data.GetObject());
    }
    
}



export interface BalanceSync {
    currencyId: string,
    quantity: number,
}

export interface InventorySync {
    productId: string,
    inventoryAction: InventoryAction,
}

export enum InventoryAction{
    Removed = -1,
    Used,
    Added,
}

export enum Currency{
    star = "star",
    energy = "energy",
}

import { ZepetoScriptBehaviour } from 'ZEPETO.Script';
import { Button, Text, ToggleGroup } from 'UnityEngine.UI';
import { GameObject, Object, Sprite, Transform, WaitUntil } from 'UnityEngine';
import { InventoryRecord, InventoryService } from "ZEPETO.Inventory";
import { CurrencyService } from "ZEPETO.Currency";
import { ProductRecord, ProductService, PurchaseType } from "ZEPETO.Product";
import { ZepetoWorldMultiplay } from "ZEPETO.World";
import { Room, RoomData } from "ZEPETO.Multiplay";
import ITM_Inventory from './ITM_Inventory';
import { BalanceSync, InventorySync, Currency } from "./UIBalances";

export default class UIInventory extends ZepetoScriptBehaviour {
    @SerializeField() private usedSlotNumTxt : Text;
    @SerializeField() private possessionStarTxt : Text;
    @SerializeField() private useBtn : Button;
    
    @SerializeField() private contentParent : Transform;
    @SerializeField() private prefItem : GameObject;
    @SerializeField() private itemImage : Sprite[];
    
    private _inventoryCache: InventoryRecord[];
    private _productCache: Map<string, ProductRecord> = new Map<string, ProductRecord>();
    private _multiplay : ZepetoWorldMultiplay;
    private _room : Room;

    private Start() {
        this._multiplay = Object.FindObjectOfType<ZepetoWorldMultiplay>();
        this._multiplay.RoomJoined += (room: Room) => {
            this._room = room;
            this.InitMessageHandler();
        }
        
        this.StartCoroutine(this.LoadAllItems());
    }
    
    private InitMessageHandler(){
        ProductService.OnPurchaseCompleted.AddListener((product, response) => {
            this.StartCoroutine(this.RefreshInventoryUI());
            this.StartCoroutine(this.RefreshBalanceUI());
        });
        this._room.AddMessageHandler<InventorySync>("SyncInventories", (message) => {
            this.StartCoroutine(this.RefreshInventoryUI());
        });
        this._room.AddMessageHandler<BalanceSync>("SyncBalances", (message) => {
            this.StartCoroutine(this.RefreshBalanceUI());
        });
        this.useBtn.onClick.AddListener(()=> this.OnClickUseInventoryItem());
    }

    private *LoadAllItems() {
        const request = ProductService.GetProductsAsync();
        yield new WaitUntil(() => request.keepWaiting == false);
        if (request.responseData.isSuccess) {
            request.responseData.products.forEach((pr) => {
                this._productCache.set(pr.productId,pr);
            });
        }

        this.StartCoroutine(this.RefreshInventoryUI());
        this.StartCoroutine(this.RefreshBalanceUI());
    }
    
    private *RefreshInventoryUI(){
        const request = InventoryService.GetListAsync();
        yield new WaitUntil(() => request.keepWaiting == false);
        if(request.responseData.isSuccess) {
            const items: InventoryRecord[] = request.responseData.products;
            
            items.forEach((ir, index) => {
                // If there are zero consumable items, delete them from the inventory.
                if (ir.quantity <= 0 && this._productCache.get(ir.productId).PurchaseType == PurchaseType.Consumable) {
                    // Remove inventory
                    const data = new RoomData();
                    data.Add("productId", ir.productId);
                    this._multiplay.Room?.Send("onRemoveInventory", data.GetObject());
                    return;
                }

            });

            // If the value matches the previously received value, do not update it.
            if (this._inventoryCache === items) 
                return;
            else if (items != null && this._inventoryCache?.length == items.length) 
                this.UpdateInventory(items);
            else
                this.CreateInventory(items);

            this.usedSlotNumTxt.text = items.length.toString();
            this._inventoryCache = items;
        }
    }
    
    private UpdateInventory(items:InventoryRecord[]){
        const itemScripts = this.contentParent.GetComponentsInChildren<ITM_Inventory>();
        items.forEach((ir) => {
            itemScripts.forEach((itemScript) => {
                if(itemScript.itemRecord.productId == ir.productId) {            
                    const isShowQuantity:boolean = this._productCache.get(ir.productId).PurchaseType == PurchaseType.Consumable;
                    itemScript.RefreshItem(ir, isShowQuantity);
                    return;
                }
            });
        });
    }
    
    private CreateInventory(items :InventoryRecord[]){
        this.contentParent.GetComponentsInChildren<ITM_Inventory>().forEach((child) => {
            GameObject.Destroy(child.gameObject);
        });

        // Sort by Create Order (descending order)
        items.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
        
        items.forEach((ir, index) => {
            const itemObj = Object.Instantiate(this.prefItem, this.contentParent) as GameObject;

            const itemScript = itemObj.GetComponent<ITM_Inventory>();
            this.itemImage.forEach((s, index) => {
                // Import by name comparison from image resources.
                if (s.name == ir.productId) {
                    itemScript.itemImage.sprite = this.itemImage[index];
                    return;
                }
            });
            // Non-consumable items do not display numbers.
            const isShowQuantity:boolean = this._productCache.get(ir.productId).PurchaseType == PurchaseType.Consumable;
            itemScript.RefreshItem(ir, isShowQuantity);
            itemScript.isOn(index == 0);
        });
    }
    
    private *RefreshBalanceUI(){
        const request = CurrencyService.GetUserCurrencyBalancesAsync();
        yield new WaitUntil(() => request.keepWaiting == false);
        if(request.responseData.isSuccess) {
            this.possessionStarTxt.text = request.responseData.currencies.ContainsKey(Currency.star) ? request.responseData.currencies.get_Item(Currency.star).toString() : "0";
        }
        else{
            console.log(request.responseData.ErrorCode);
        }
    }
    

    private OnClickUseInventoryItem(){
        const toggleGroup = this.contentParent.GetComponent<ToggleGroup>();
        const item = toggleGroup.GetFirstActiveToggle()?.GetComponent<ITM_Inventory>().itemRecord;
        
        if(item == null){
            console.warn("no have item data");
            return;
        }
        if(this._multiplay.Room == null){
            console.warn("server disconnect");
            return;
        }

        const data = new RoomData();
        data.Add("productId", item.productId);
        data.Add("quantity", 1);
        this._multiplay.Room?.Send("onUseInventory", data.GetObject());
    }

}

import { ZepetoScriptBehaviour } from 'ZEPETO.Script';
import { Button, Text } from 'UnityEngine.UI';
import { GameObject, Object, WaitUntil, WaitForSeconds } from 'UnityEngine';
import { ProductRecord, ProductService, ProductType, PurchaseType } from "ZEPETO.Product";
import { ZepetoWorldMultiplay } from "ZEPETO.World";
import { Room, RoomData } from "ZEPETO.Multiplay";
import UIBallances, { BalanceSync, Currency, InventoryAction, InventorySync } from "./UIBalances";

export default class UICommonBtn extends ZepetoScriptBehaviour {
    @SerializeField() private gainBalanceBtn: Button;
    @SerializeField() private useBalanceBtn: Button;
    @SerializeField() private increaseExpBtn: Button;
    @SerializeField() private acquireRandomItemBtn: Button;
    @SerializeField() private purchaseImmediatelyBtn: Button;
    @SerializeField() private purchaseOfficialUIBtn: Button;
    @SerializeField() private purchaseItemPackageBtn: Button;
    @SerializeField() private informationPref: GameObject;

    private _itemsCache: ProductRecord[] = [];
    private _itemsPackageCache: ProductRecord[] = []
    private _multiplay: ZepetoWorldMultiplay;
    private _room : Room;
    private _uiBallances: UIBallances;

    private Start() {
        this._multiplay = Object.FindObjectOfType<ZepetoWorldMultiplay>();
        this._uiBallances = Object.FindObjectOfType<UIBallances>();

        // Button Interval
        let allBtns : Button[] = this.GetComponentsInChildren<Button>();
        allBtns.forEach(btn => btn.onClick.AddListener(() => this.StartCoroutine(this.BtnInterval(btn))));
        
        this.StartCoroutine(this.LoadAllItems());

        this._multiplay.RoomJoined += (room: Room) => {
            this._room = room;
            this.InitMessageHandler();
        }
    }
    
    private InitMessageHandler() {
        // Button listener
        this.gainBalanceBtn.onClick.AddListener(() => this.OnClickGainBalance(Currency.energy, 1));
        this.useBalanceBtn.onClick.AddListener(() => this.OnClickUseBalance(Currency.energy, 1));
        this.increaseExpBtn.onClick.AddListener(() => this.OnClickIncreaseExp());
        this.acquireRandomItemBtn.onClick.AddListener(() => this.OnClickAcquireRandomItem());
        // Sell items with id called potion1.
        this.purchaseImmediatelyBtn.onClick.AddListener(() => this.StartCoroutine(this.OnClickPurchaseItemImmediately("potion1")));
        this.purchaseOfficialUIBtn.onClick.AddListener(() => {
            // The first non-consumable item is sold through the official ui.
            const nonConsumableItem = this._itemsCache.find(ir => ir.PurchaseType === PurchaseType.NonConsumable);
            if (nonConsumableItem) {
                this.OnClickPurchaseItem(nonConsumableItem);
            }
            else{
                this.OpenInformation(`Non-consumable product does not exist.`);
            }
        });
        this.purchaseItemPackageBtn.onClick.AddListener(() => {
            const packageItem = this._itemsPackageCache[0];
            if (packageItem) {
                this.OnClickPurchaseItem(packageItem);
            }
            else{
                this.OpenInformation(`Item package product does not exist.`);
            }
        });

        
        // Log message handler
        this._room.AddMessageHandler<BalanceSync>("SyncBalances", (message) => {
            this.OpenInformation(`${message.currencyId} a Increase or decrease: ${message.quantity}`);
        });
        this._multiplay.Room.AddMessageHandler<InventorySync>("SyncInventories", (message) => {
            this.OpenInformation(`${message.productId} has been ${InventoryAction[message.inventoryAction]} in the inventory.`);
            // Item use sample
            /*if(message.inventoryAction == InventoryAction.Used){
                if(message.productId == "potion1"){
                    console.log("potion use!");
                }
            }*/
        });
        this._room.AddMessageHandler<string>("DebitError", (message) => {
            this.OpenInformation(message);
        });
        ProductService.OnPurchaseCompleted.AddListener((product, response) => {
            this.OpenInformation(`${response.productId} Purchase Completed`);
        });
        ProductService.OnPurchaseFailed.AddListener((product, response) => {
            this.OpenInformation(response.message);
        });
    }

    private *LoadAllItems() {
        const request = ProductService.GetProductsAsync();
        yield new WaitUntil(() => request.keepWaiting == false);
        if (request.responseData.isSuccess) {
            this._itemsCache = [];
            request.responseData.products.forEach((pr) => {
                if (pr.ProductType == ProductType.Item) {
                    this._itemsCache.push(pr);
                }
                if (pr.ProductType == ProductType.ItemPackage) {
                    this._itemsPackageCache.push(pr);
                }
            });

            if (this._itemsCache.length == 0) {
                console.warn("no Item information");
                return;
            }
        }
        else{
            console.warn("Product Load Failed");
        }
    }
    
    private OpenInformation(message:string){
        const inforObj = GameObject.Instantiate(this.informationPref,this.transform.parent) as GameObject;
        inforObj.GetComponentInChildren<Text>().text = message;
    }

    private OnClickGainBalance(currencyId: string, quantity: number) {
        const data = new RoomData();
        data.Add("currencyId", currencyId);
        data.Add("quantity", quantity);
        this._multiplay.Room?.Send("onCredit", data.GetObject());
    }

    private OnClickUseBalance(currencyId: string, quantity: number) {
        const data = new RoomData();
        data.Add("currencyId", currencyId);
        data.Add("quantity", quantity);
        this._multiplay.Room?.Send("onDebit", data.GetObject());
    }
    
    private OnClickIncreaseExp() {
        // This is just a test code that you don't save.
        this._uiBallances.IncreaseExp(10);
    }

    private OnClickAcquireRandomItem() {
        if (this._itemsCache.length == 0) {
            console.warn("Item cache has not yet been loaded.");
            return;
        }
                   
        // Choose one of the consumable items.
        const consumableItem: ProductRecord[] = [];
        this._itemsCache.forEach((pr)=>{
           if(pr.PurchaseType == PurchaseType.Consumable)
               consumableItem.push(pr);
        });
        
        const randNum = Math.floor(Math.random() * consumableItem.length);
        const randItem = consumableItem[randNum];

        const data = new RoomData();
        data.Add("productId", randItem.productId);
        data.Add("quantity", 1);
        this._multiplay.Room?.Send("onAddInventory", data.GetObject());
    }

    // An immediate purchase
    private *OnClickPurchaseItemImmediately(productId: string) {
        const request = ProductService.PurchaseProductAsync(productId);
        yield new WaitUntil(() => request.keepWaiting == false);
        if (request.responseData.isSuccess) {
            // Is purchase success
        } else {
            // Is purchase fail
        }
    }
    
    // Open offical ui
    private OnClickPurchaseItem(productRecord: ProductRecord) {
        ProductService.OpenPurchaseUI(productRecord);
    }
    
    private *BtnInterval(btn:Button){
        btn.interactable = false;
        yield new WaitForSeconds(0.2);

        btn.interactable = true;
    }
}

private *LoadAllItems() {
  const request = ProductService.GetProductsAsync();
  yield new WaitUntil(() => request.keepWaiting == false);
  if (request.responseData.isSuccess) {
    ...

  }
  else{
      console.warn("Product Load Failed");
  }
}

import { ZepetoScriptBehaviour } from 'ZEPETO.Script';
import { Button, Text } from 'UnityEngine.UI';
import { WaitUntil, GameObject } from 'UnityEngine';
import { CurrencyService } from "ZEPETO.Currency";
import { CurrencyPackageUnitRecord, ProductRecord, ProductService, ProductType } from "ZEPETO.Product";
import ITM_ShopProduct from './ITM_ShopProduct';

export default class UIShop extends ZepetoScriptBehaviour {
    @SerializeField() private possessionZemTxt : Text;
    @SerializeField() private shopProducts : GameObject[];
    
    private _products : ProductRecord[];
    
    private Start() {
        this.StartCoroutine(this.RefreshZemUI());
        this.StartCoroutine(this.RefreshProducts());
        
        ProductService.OnPurchaseCompleted.AddListener((productRecord, response) => {
            this.StartCoroutine(this.RefreshZemUI());
        });
    }
    
    private *RefreshZemUI(){
        const request = CurrencyService.GetOfficialCurrencyBalanceAsync();
        
        yield new WaitUntil(() => request.keepWaiting == false);
        if(request.responseData.isSuccess) {
            this.possessionZemTxt.text = request.responseData.currency.quantity.toString();
        }
    }
    
    private *RefreshProducts(){
        const request = ProductService.GetProductsAsync();
        yield new WaitUntil(() => request.keepWaiting == false);

        if (!request.responseData || !request.responseData.isSuccess) {
            console.warn("Refresh Products Failed");
            return;
        }

        let currencyPackageIndex = 0;
        for (const product of request.responseData.products || []) {
            if (product.ProductType === ProductType.CurrencyPackage && currencyPackageIndex < this.shopProducts.length) {
                this.shopProducts[currencyPackageIndex].GetComponent<ITM_ShopProduct>().RefreshProduct(product);
                currencyPackageIndex++;
            }
        }
    }

}

import { Sandbox, SandboxOptions, SandboxPlayer } from "ZEPETO.Multiplay";
import { DataStorage } from "ZEPETO.Multiplay.DataStorage";
import { loadCurrency } from "ZEPETO.Multiplay.Currency";
import { loadInventory } from "ZEPETO.Multiplay.Inventory";
import { loadDataStorage } from 'ZEPETO.Multiplay.DataStorage';

export default class extends Sandbox {

    storageMap: Map<string, DataStorage> = new Map<string, DataStorage>();

    constructor() {
        super();
    }

    async onCreate(options: SandboxOptions) {

        this.onMessage("onCredit", (client, message:CurrencyMessage) => {

            console.log(`[onCredit]`);
            const currencyId = message.currencyId;
            const quantity = message.quantity ?? 1;
            
            this.AddCredit(client, currencyId, quantity);
        });
        
        this.onMessage("onDebit", (client, message:CurrencyMessage) => {

            console.log(`[onDebit]`);
            const currencyId = message.currencyId;
            const quantity = message.quantity ?? 1;

            this.OnDebit(client, currencyId, quantity);
        });


        this.onMessage("onAddInventory", (client, message:InventoryMessage) => {

            console.log(`[onAddInventory]`);
            const productId = message.productId;
            const quantity = message.quantity ?? 1;

            this.AddInventory(client, productId, quantity);
        });


        this.onMessage("onUseInventory", (client, message:InventoryMessage) => {

            console.log(`[onUseInventory]`);
            const productId = message.productId;
            const quantity = message.quantity ?? 1;

            this.UseInventory(client, productId, quantity);
        });

        this.onMessage("onRemoveInventory", (client, message:InventoryMessage) => {

            console.log(`[onRemoveInventory]`);
            const productId = message.productId;

            this.RemoveInventory(client, productId);
        });


        // DataStorage
        this.onMessage("onSetStorage", (client, message:StorageMessage) => {

            console.log(`[onSetStorage]`);
            const key = message.key;
            const value = message.value ?? "";
            this.SetStorage(client, key, value);
        });

        this.onMessage("onGetStorage", (client, message:StorageMessage) => {

            const key = message.key;
            console.log(`[onGetStorage] ${key}`);

            this.GetStorage(client, key);
        });

    }

    async SetStorage(client: SandboxPlayer, key: string, value: string) {

        try {
            const dataStorage = await loadDataStorage(client.userId);
            const result = await dataStorage.set(key, value);
            client.send("onSetStorageResult", result);
        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }



    async GetStorage(client: SandboxPlayer, key: string) {

        try {
            const dataStorage = await loadDataStorage(client.userId);
            const result = await dataStorage.get(key) as string;

            if (result === undefined) {
                // It is an empty string
                client.send("onGetStorageResult", "");
            } else
            {
                client.send("onGetStorageResult", result);
            }

        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }


    async AddInventory(client: SandboxPlayer, productId: string, quantity: number) {

        try {
            const inventory = await loadInventory(client.userId);
            await inventory.add(productId, quantity);
            const inventorySync: InventorySync = {
                productId : productId,
                inventoryAction : InventoryAction.Add
            }
            client.send("SyncInventories",inventorySync);
            console.log("success add");

        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }


    async UseInventory(client: SandboxPlayer, productId: string, quantity: number) {

        try {
            const inventory = await loadInventory(client.userId);
            if (await inventory.use(productId, quantity) === true) {
                const inventorySync: InventorySync = {
                    productId: productId,
                    inventoryAction: InventoryAction.Use
                }
                client.send("SyncInventories", inventorySync);
                console.log("success use");

            }
            else{
                console.log("use error");
            }
        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }


    async RemoveInventory(client: SandboxPlayer, productId: string) {

        try {
            const inventory = await loadInventory(client.userId);
            if (await inventory.remove(productId) === true) {
                const inventorySync: InventorySync = {
                    productId: productId,
                    inventoryAction: InventoryAction.Remove
                }
                client.send("SyncInventories", inventorySync);
                console.log("success rm");
            }
            else{
                console.log("remove error");
            }
        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }



    async AddCredit(client: SandboxPlayer, currencyId: string, quantity: number) {

        try {
            const currency = await loadCurrency(client.userId);
            await currency.credit(currencyId, quantity);
            const currencySync: CurrencyMessage = {
                currencyId : currencyId,
                quantity : quantity
            }
            client.send("SyncBalances",currencySync);
        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }

    async OnDebit(client: SandboxPlayer, currencyId: string, quantity: number) {

        try {
            const currency = await loadCurrency(client.userId);
            if(await currency.debit(currencyId, quantity) === true) {
                const currencySync: CurrencyMessage = {
                    currencyId: currencyId,
                    quantity: -quantity
                }
                client.send("SyncBalances", currencySync);
            }
            else{
                //It's usually the case that there's no balance.
                client.send("DebitError", "Currency Not Enough");
            }
        }
        catch (e)
        {
            console.log(`${e}`);
        }
    }


    onJoin(client: SandboxPlayer) {
        
    }

    onTick(deltaTime: number): void {
        
    }

    onLeave(client: SandboxPlayer, consented?: boolean) {
        
    }
    
}

interface CurrencyMessage {
    currencyId: string,
    quantity?: number,
}

interface InventoryMessage {
    productId: string,
    quantity?: number,
}

interface StorageMessage {
    key: string,
    value?: string,
}

interface InventorySync {
    productId: string,
    inventoryAction: InventoryAction,
}

export enum InventoryAction{
    Remove = -1,
    Use,
    Add,
}