Method and system for verifying transactions in a client-server environment

Abstract

A method (300) for verifying a transaction in a client-server environment is disclosed, the method comprising: receiving a transaction request from a user at a client device (102); executing a command at the client device related to the transaction request based on state data corresponding to the user at the client device; when the command is executed at the client device, sending a request to the server (104) for the execution of the command by the server by the client device; when the request is received from the client device, executing a command by the server using a copy of the state data stored in the server; and executing a command by the server to verify the transaction related to the transaction request at the client device at the server; and performing one of the steps of allowing or preventing the transaction at the client device by the server based on the execution of the command by the server.

Description

Technology Field

[0001] The present invention relates to client-server systems, and more specifically, to a method and system for verifying transactions in a client-server environment. Background Technology

[0002] In game applications using a client-server environment, cheat applications are sometimes used on the client device to give a player (user) an unfair advantage over other players by exposing one or more game states or other information otherwise hidden from the player. In many cases, such cheat applications are also used to modify the application's expected logic flow, alter values ​​in application memory, and intercept and modify client-server messages. Typically, cheat applications can manipulate the game client program to enhance the player's abilities. Cheat applications typically use Application Programming Interfaces (APIs) provided with the game program to manipulate program behavior and extract information about the game, or the player may intercept graphical commands issued by the program to the operating system.

[0003] Here, cheating and other unauthorized actions by a player using a client device can also be committed to harm other players and cause a general disruption to the operation of the game. For example, in the game environment, a player may attempt to purchase a card from the game store and realize that their coin balance is zero, making it insufficient to legally purchase the card. The player subsequently uses a cheat application to modify the bank balance on the game client to report that they have sufficient currency to purchase the card, and when the purchase transaction is completed, they receive the card they were not originally granted, which compromises the balance and integrity of the game for all other users interacting with that player, while simultaneously damaging the game's economics.

[0004] To maintain a consistent and secure client-server environment, it is necessary to make authoritative decisions under the control of either the client device or the server. However, making authoritative decisions by the server can be difficult due to the development time required to maintain separate client and server codebases, and it can also lead to errors during gameplay because working across multiple programming languages ​​for both the client device and the server is complex. Furthermore, maintaining separate client and server codebases introduces overhead on the server as well as a communication layer between the client device and the server. Moreover, if the client device needs to communicate with the server merely to obtain failure results, this incurs additional overhead.

[0005] Therefore, in light of the above discussion, there is a need to overcome the aforementioned disadvantages associated with existing technologies for providing methods and systems for verifying transactions in a client-server environment.

[0006] The present invention aims to provide a method for verifying transactions in a client-server environment. The present invention also aims to provide a system for verifying transactions in a client-server environment. The objective of the present invention is to provide a solution that at least partially overcomes the problems faced in the prior art by providing a technology for verifying transactions in a client-server environment using common logic code sensitive to game logic on a client device and a server to ensure security and a consistent player experience. In order for the server to verify transactions, commands related to the common logic code are executed on both the client device and the server using a copy of state data that is maintained in an undamaged state on the server. The commands are written in a programming language for either the client device or the server, translated into another programming language for the other, and executed on both the client device and the server while maintaining logic synchronization; the execution results of the commands are compared for consistency and the transactions are verified.

[0007] In one embodiment, the present invention provides a method for verifying a transaction in a client-server environment, said method comprising:

[0008] - A step of receiving a transaction request from a user on a client device;

[0009] - A step of executing a command on a client device associated with a transaction request based on state data corresponding to the user on the client device;

[0010] - When a command is executed on the client device, the client device sends a request to the server to execute the command;

[0011] - A step in which, upon receiving a request from a client device, the server executes a command using a copy of the state data stored on the server to verify a transaction related to the transaction request from the client device; and

[0012] - Includes a step of performing either allowing or blocking a transaction on the client device by the server based on the execution of a command on the server.

[0013] In another aspect, one embodiment of the present invention provides a system for verifying a transaction in a client-server environment, said system:

[0014] - As a client device,

[0015] - Receive a transaction request from the user, and

[0016] - Execute commands related to transaction requests based on state data corresponding to the user on the client device, and

[0017] - A client device configured to send a request to the server for the execution of a command on the server when a command is executed on the client device;

[0018] - As a server coupled to enable communication with client devices via a network,

[0019] - When a request is received from a client device, the client device executes a command using a copy of the stored state data to verify the transaction related to the transaction request, and

[0020] - Includes a server configured to perform at least one of allowing or preventing a transaction on a client device by the server based on the execution of a command on the server.

[0021] Embodiments of the present invention provide a technique for verifying transactions in a client-server environment by using common commands between a client device and a server based on logic synchronization, which substantially eliminates or at least partially resolves the aforementioned problems in the prior art, reduces the overhead required to maintain separate client codebases and server codebases and the communication layer between them, and also reduces any additional overhead caused by the client device communicating with the server to obtain only failure results.

[0022] Further aspects, advantages, features, and objects of the present invention will become apparent from the detailed description and drawings of exemplary embodiments interpreted together with the following appended claims.

[0023] It will be understood that the features of the present invention are easily combined in various combinations without departing from the scope of the present invention as defined by the appended claims. Brief explanation of the drawing

[0024] The summary above, as well as the following detailed description of exemplary embodiments, is better understood when read in conjunction with the accompanying drawings. For the purpose of illustrating the invention, exemplary configurations of the invention are shown in the drawings. However, the invention is not limited to the specific methods and tools disclosed herein. Furthermore, those skilled in the art will understand that the drawings are not scaled. Where possible, similar elements have been indicated by the same numbers. Now, embodiments of the present invention will be described with reference only to, for example, the following drawings: FIG. 1 is a schematic example of a transaction verification system in a client-server environment according to one embodiment of the present invention; FIG. 2 is an interaction diagram illustrating an exemplary scenario for verifying the validity of a transaction in a game environment according to an exemplary scenario; FIG. 3 is a flowchart of a method for listing steps to verify the validity of a transaction in a client-server environment according to an embodiment of the present invention. In the attached drawings, underlined numbers are used to indicate the item where the underlined number is located or the item adjacent to the underlined number. Non-underlined numbers refer to the item identified by the line connecting it to the underlined number. If a non-underlined number has an associated arrow, the underlined number is used to identify the general item indicated by the arrow. Specific details for implementing the invention

[0025] The following detailed description illustrates embodiments of the present invention and methods by which they may be implemented. Although some modes of carrying out the present invention have been disclosed, those skilled in the art will recognize that other embodiments for carrying out or practicing the present invention are also possible.

[0026] In one embodiment, the present invention provides a method for verifying a transaction in a client-server environment, said method comprising:

[0027] - A step of receiving a transaction request from a user on a client device;

[0028] - A step of executing a command on a client device associated with a transaction request based on state data corresponding to a user on a client device;

[0029] - When a command is executed on a client device, the client device sends a request to the server for the execution of the command;

[0030] - A step in which, upon receiving a request from a client device, the server executes a command using a copy of the state data stored on the server to verify the transaction related to the transaction request from the client device; and

[0031] - Includes a step of performing either allowing or blocking a transaction on a client device by the server, based on the execution of a command on the server.

[0032] In another aspect, one embodiment of the present invention provides a system for verifying a transaction in a client-server environment, said system:

[0033] - As a client device,

[0034] - Receive a transaction request from the user, and

[0035] - Execute commands related to transaction requests based on state data corresponding to the user on the client device, and

[0036] - A client device configured to send a request to the server for the execution of a command on the server when a command is executed on the client device;

[0037] - As a server coupled to enable communication with client devices via a network,

[0038] - When a request is received from a client device, the client device executes a command using a copy of the state data stored on the server to verify the transaction related to the transaction request, and

[0039] - Includes a server configured to perform at least one of allowing or preventing a transaction on a client device by the server based on the execution of a command on the server.

[0040] The present invention provides a method for verifying a transaction in a client-server environment. The method of the present invention verifies the validity of a transaction when receiving a transaction request from a user of a client device by executing a command on the client device and on the server. The execution of the command on the client device and on the server ensures security and a consistent player experience. The method of the present invention prevents a cheat application from providing an arbitrary unfair advantage to a user over other users by executing a common command on the server using a copy of state data in an upcompromised state on the server and verifying the transaction based on the execution of the command.

[0041] The above method includes the step of receiving a transaction request from a user on a client device. Throughout the invention, the term “transaction request” means a request for a transaction involving the exchange of one or more resources to acquire an asset by a user on an application on a client device. The client device includes, but is not limited to, a computer, a mobile phone, a laptop computer, a tablet, a thin computing device, a personal digital assistant (PDA), a portable computing device, a virtual machine, or a suitable device having a processor. In certain embodiments, the client device may represent a device capable of supporting a connection to an audio player, a game console, a camera, a camcorder, an audio device, a video device, a multimedia device, or a remote computing device. In one embodiment, the client device includes at least a processor and memory.

[0042] The above method includes the step of executing a command on a client device associated with a transaction request based on state data corresponding to a user on the client device. In the present invention, the term “state data” refers to data associated with one or more state parameters associated with client-server interaction in a client-server environment. A client-server environment includes a client device comprising one or more processors, memory, and optionally a microphone, speaker, display, and server. For example, state data may refer to any data associated with a computer-implemented game application that can affect one or more game state parameters, including, for example and without limitation, changes to player data or metadata, changes to player social connections or contacts, player input to the game, and events generated by game logic. In some embodiments, each application data has a name and a value. The value of the application data may change at any time in response to the player’s gameplay or in response to the game engine (e.g., based on game logic).

[0043] Optionally, the state data is stored in memory associated with the client device. The memory may store content and data relating to and enabling the operation of the client-server environment as digital data objects. Digital data objects may generally include objects of digital information stored or implemented in data files, databases, or records. Content may include, for example, text, images, graphics (vector-based or bitmap), audio, video, or other multimedia, and combinations thereof. Content object data may also include executable code objects (e.g., games executable within a browser window or frame), etc.

[0044] Optionally, state data is stored in one or more of various distinct integrated databases associated with the client device, such as relational databases and object-oriented databases, which maintain information as an integrated set of logically related records or files stored on one or more physical systems.

[0045] Optionally, resources include credits earned by the user in applications on the client device. Applications may include, for example, game applications, virtual reality applications, augmented reality applications, and other client-server interaction-based applications. Such resources may be earned by the user through the course of gameplay by using real currency and / or by completing some challenges or levels, etc.

[0046] Optionally, the execution of the command is based on verification of the existence of a sufficient resource balance to complete the transaction. That is, the command is executed only when there is a sufficient resource balance required to complete the transaction. As discussed, the resource balance may refer to the current (remaining) balance of some virtual currency or credits used in the application (e.g., a game application).

[0047] Optionally, a transaction involves exchanging resources to acquire assets by a user within an application on a client device. As discussed, resource balances may refer to some virtual currency or credits used within the application. Such resources may be used by the user within the gameplay to purchase various items, such as new weapons, powers, and character upgrades, for example, to enhance gameplay.

[0048] Here, a command is executed on a client device to initiate a transaction based on a transaction request. For example, if a user wishes to perform a purchase transaction using some credits while using a game application on a client device, the user sends a purchase transaction request to the client device, and the client device executes a command to initiate the transaction. In particular, the execution of the command succeeds when there is a sufficient resource balance in the state data associated with the user, and the execution of the command fails when there is not a sufficient resource balance in the state data associated with the user.

[0049] The above method further includes the step of transmitting a request from the client device to the server for the execution of the command when the command is executed on the client device. In particular, in some embodiments, when there is a sufficient resource balance in the state data associated with the user, the request is transmitted to the server upon successful execution of the command on the client device. In some embodiments, when there is not a sufficient resource balance in the state data, the execution of the command fails to terminate the transaction, and no message is transmitted to the server. In particular, a request for the execution of the command is transmitted to the server, and the server uses a copy of the state data on the server to validate the transaction associated with the transaction request. In many cases, the state data on the client device may be corrupted by the user using a cheat application on the client device. However, since the copy of the state data on the server remains uncorrupted, it is used to validate the transaction.

[0050] Optionally, the client device is coupled to the server so as to be communicable via a communication network. In several embodiments, the server includes, but is not limited to, a computer, a laptop computer, a computing device, a virtual machine, a desktop session, an open application, or a suitable device having a processor. In several embodiments, the server includes one or more computing devices.

[0051] Optionally, the client device connects to the server via a communication network, for example, via a modem connection, a local area network connection including, for example, Ethernet or broadband, a wide area network connection, or a mobile network connection. Examples of communication networks include, but are not limited to, local area network (LAN) networks, wide area network (WAN) networks, wireless networks, the Internet, intranets, or other networks.

[0052] The above method further includes the step of the server executing a command using a copy of the state data stored on the server to verify a transaction related to the transaction request from the client device when the server receives a request from the client device. Here, the execution of the command by the server includes the step of converting a command related to the client device into a server command executable on the server based on the logic code of the client device. In particular, logic code written once for the client device is reused on the server. In several embodiments, the logic code can be reused across multiple platforms, thereby eliminating the need to write separate code to process logic on various devices or platforms. Additionally, the messaging layer from the client device to the server is also converted by reusing the logic code. Reusing logic code or common commands reduces the overhead from development time required to maintain separate client codebases and server codebases, as well as the communication layer between the client device and the server.

[0053] Here, the copy of the state data on the server is not corrupted by a cheat application that is stored in server memory and can be used by a user on a client device. Because the copy of the state data on the server is not corrupted, the execution of a command on the server enables the validation of the transaction. For example, if the execution of a command on the client device indicates the existence of a sufficient resource balance in the state data on the client device, the execution of the command on the server verifies that a sufficient resource balance actually exists in the copy of the state data and has not been tampered with or corrupted by a user using a cheat application on the client device, thereby enabling the validation of the transaction.

[0054] The above method further includes the step of performing either allowing or preventing a transaction on the client device by the server based on the execution of a command on the server. Here, if the command is successful on the server as well, the server notifies the client device of the success of the command, which in turn validates the existence of a sufficient resource balance in the state data, and thereby the command is executed on both the client device and the server to maintain the state data and a copy of the state data in a synchronized state. If the command fails, the server notifies the client device of the failure of the command, the client device handles an error case such as terminating the session, and the state data remains valid. Here, it can be understood that a transaction is allowed when a sufficient resource balance exists in the copy of the state data on the server, and a transaction is prevented when a sufficient resource balance does not exist in the copy of the state data on the server.

[0055] Optionally, the step of executing a command on the server includes converting a command associated with the client device into a server command executable on the server based on the logic code of the client device. Here, the command (sometimes referred to as a common command) is written in a programming language for either the client device or the server, converted into a different programming language for the other, and the execution results of the command are compared to verify the consistency and validity of the transaction. The common command is associated with common logic code (thereby maintaining logic synchronization). The common command is sensitive to game logic on the client device and the server, and is executed on the client device using state data associated with the user, and on the server using a copy of the state data maintained in an uncorrupted state on the server, in order to validate the transaction by the server. Validating the transaction by the server based on logic synchronization by reusing logic code that has been used once on the client device and reused on the server reduces the overhead required to maintain separate client and server codebases, and also reduces the overhead caused by the communication layer between the client device and the server that would otherwise have been required while using separate codebases on the client device and the server.

[0056] In several embodiments, the logic code can be reused across multiple platforms associated with a client-server environment, thereby eliminating the need to write separate code to handle logic on various devices or platforms. Additionally, the messaging layer from the client device to the server is also transformed by reusing the logic code. The method of the present invention also reduces any additional overhead caused by the client device communicating with the server merely to obtain failure results.

[0057] Optionally, the step of allowing or blocking a transaction on a client device by a server includes generating a trust score for the user based on at least one of the user's previous transactions and validating the validity of the transaction based on the user's trust score. In particular, a first user who has repeatedly obtained permission for a transaction over several instances may obtain a higher trust score compared to a second user who may fail in some instances. A higher trust score may lead to the server allowing transactions by the first user in some instances without the need to validate the transaction on the server for each of these instances. This can help reduce the overhead on the server required to validate every single transaction. Since it can be recognized that instances where a transaction may not be validated by the server for a user with a high trust score (i.e., a trust score exceeding a predefined threshold) may be determined randomly (pseudo-randomly), even a user with a high trust score cannot deceive the server's transaction validation function.

[0058] The present invention also relates to a system as described above. Various embodiments and modifications disclosed above are applied to said system.

[0059] The system of the present invention verifies a transaction when receiving a transaction request from a user of a client device by executing a common command on the client device and the server. The system of the present invention ensures security and a consistent player experience through the execution of the common command on the client device and the server. Furthermore, the common command is associated with common logic code and is sensitive to the game logic on the client device and the server; to verify the validity of the transaction by the server, it is executed on the client device and the server using a copy of state data maintained in an undamaged state on the server. Additionally, the common command (hereinafter referred to as "command") is written in a programming language for either the client device or the server, converted into another programming language for the other, and the execution results of the command are compared to verify the consistency and validity of the transaction. The system of the present invention reduces the overhead required to maintain separate client codebases and server codebases, and also reduces the overhead caused by the communication layer between the client device and the server that would otherwise be required by using separate codebases on the client device and the server based on logic synchronization and transaction validity verification by the server, by reusing logic code written once for the client device on the server. The system of the present invention also reduces any additional overhead caused by a client device communicating with a server merely to obtain failure results. In several embodiments, the logic code can be reused across multiple platforms associated with a client-server environment, thereby eliminating the need to write separate code to process logic on various devices or platforms. Additionally, the messaging layer from the client device to the server is also transformed by reusing the logic code.

[0060] The above system includes a client device and a server coupled to the client device so as to be communicable via a network, wherein the client device receives a transaction request from a user, executes a command related to the transaction request based on state data corresponding to the user of the client device, and is configured to transmit a request to the server for the execution of the command when the command is executed on the client device.

[0061] Optionally, the execution of the command is based on verification of the existence of a sufficient resource balance to complete the transaction.

[0062] Optionally, the transaction includes exchanging resources to acquire assets by a user in an application on a client device.

[0063] Optionally, resources include credits earned by the user in applications on the client device.

[0064] The above system includes a server configured to execute a command using a copy of stored state data to verify the validity of a transaction related to a transaction request from a client device when receiving a request from a client device, and based on the execution of the command at the server, performs at least one of allowing or blocking a transaction at the client device by the server.

[0065] Herein, "server" means a structure and / or module comprising programmable and / or non-programmable components configured to store, process, and / or share information. Specifically, a server comprises any array of physical or virtual computational entities capable of enhancing information to perform various computational tasks. Furthermore, it should be recognized that a server may be a single hardware server and / or multiple hardware servers operating in a parallel or distributed architecture. In one example, a server may include components such as memory, at least one processor, a network adapter, etc., to store, process, and / or share information with other entities, such as a broadcast network or a database for storing copies of state data.

[0066] Optionally, to execute commands on the server, the server is configured to convert commands associated with the client device into server commands executable on the server based on the client device's logic code. For example, the client device and the server may be configured to operate on different operating systems, and commands executable on the client device are converted into commands executable on the server's operating system.

[0067] Optionally, the transaction is allowed when there is a sufficient resource balance in the copy of the state data on the server, and the transaction is prevented when there is not a sufficient resource balance in the copy of the state data on the server.

[0068] Optionally, the server is configured to generate a trust score for the user based on at least one of the user's previous transactions and to validate transactions based on the user's trust score.

[0069] The present invention provides a computer program product further comprising a non-transient computer-readable storage medium in which computer-readable instructions are stored, wherein the computer-readable instructions are executable by a computerized device comprising processing hardware for executing the method described above.

[0070] FIG. 1 is a schematic example of a system (100) for verifying a transaction in a client-server environment according to one embodiment of the present invention. The system (100) includes a client device (102) and a server (104) coupled to the client device (102) in a communicable manner. As illustrated, the client device (102) is coupled to the server (104) in a communicable manner via a communication network (not shown). The client device (102) includes a memory (106) and a processor (108). The server (104) includes a server memory (110) and a server processor (112).

[0071] The memory (106) and / or server memory (110) may be implemented by any suitable physical system(s) including one or more of a large class of data storage and management systems, and including components such as one or more database servers, mass storage media, media library systems, storage area networks, data storage clouds, databases (e.g., MySQL), and / or data warehouses.

[0072] The processor (108) and / or server processor (112) comprises one or more general-purpose processing units such as a microprocessor, a central processing unit, a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction (VLIW) microprocessor, or a processor implementing another instruction set, or a processor implementing a combination of other instruction sets; and one or more special-purpose processing units such as an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, etc. The processor (108) and / or server processor (112) is configured to execute instructions for performing the operations and steps discussed herein. The memory (106) is configured to store state data related to the user, and the server memory (110) is configured to store a copy of the state data related to the user.

[0073] The server (104) and client device (102) may include one or more other components, such as a network adapter, to store, process, and / or share information with other entities, such as a broadcast network or database, for receiving and storing copies of status dates.

[0074] It will be understood by those skilled in the art that FIG. 1 is merely an example for clarity and should not unduly limit the claims of this specification. Those skilled in the art will recognize many variations, alternatives, and modifications of the embodiments of the present invention.

[0075] FIG. 2 is an interaction diagram illustrating an exemplary scenario for verifying a transaction in a game environment according to an exemplary scenario. As illustrated in FIG. 2, in step (202), despite having a resource balance of 0 in his game account, the user (201) attempts to purchase a card from a store in the game environment within the client device and accordingly sends a transaction request to the client device (102). During the transaction, the user (201) uses a cheat application to modify the resource balance to report sufficient currency to the client device (102) (such as the client device (102) in FIG. 1) so that he can purchase the card. In step 204, because a sufficient resource balance is shown on the client device (102) in the status data associated with the user corrupted by the cheat application, a command related to the transaction request is executed on the client device (102). The command succeeds, and in step 206, a request is sent by the client device to the server (such as the server (104) in FIG. 1) for the execution of the command on the server. In step 208, the server (104) executes a command using a copy of the state data stored in the server (104), and since the copy of the state data is not corrupted by the cheat application, the command fails and therefore will not reflect the existence of a sufficient resource balance in the copy of the state data. In step 210, the server (104) prevents the transaction and notifies the client device (102).

[0076] FIG. 3 is a flowchart of a method (300) for listing steps for verifying a transaction in a client-server environment according to an embodiment of the present invention. In step 302, a transaction request is received from a user on a client device. In step (304), a command related to the transaction request is executed on the client device based on state data corresponding to the user on the client device. In step 306, when the command is executed on the client device, a request is sent by the client device to the server for the execution of the command on the server. In step 308, when the request is received from the client device, the command is executed by the server using a copy of the state data stored on the server to verify the transaction related to the transaction request on the client device. In step 310, based on the execution of the command on the server, either allowing the transaction on the client device or blocking the transaction is performed by the server.

[0077] It should be noted that all devices, modules, and means described herein may be implemented by software or hardware elements or any combination thereof. All steps performed by the various entities described herein, as well as functions performed by the various entities, mean that each entity is adapted or configured to perform each step and function. It should be apparent to those skilled in the art that, even if a specific function or step to be performed by an external entity in the description below of specific embodiments is not reflected in the description of a specific detail of the entity performing that specific step or function, such methods and functions may be implemented by each software or hardware element, or any combination thereof. It will be understood that the features of the invention are easy to combine in various combinations without departing from the scope of the invention as defined by the appended claims.

[0078] Modifications to the embodiments of the present invention described above are possible without departing from the scope of the invention as defined by the appended claims. Expressions such as “include,” “include,” “include,” “include,” “include,” “include,” “include,” “include,” “take,” “take,” and “take” used to describe and claim the present invention are intended to allow for the existence of items, components, or elements not explicitly described in a non-exclusive manner. References to the singular are also interpreted to relate to the plural.

Claims

Claim 1 A method (300) for verifying a purchase transaction in a game application in a client-server game environment, comprising: receiving a purchase transaction request from a user on a client device (102); wherein the purchase transaction includes exchanging resources to acquire assets by the user in the game application on the client device; wherein the client device executes a command related to the purchase transaction request based on state data corresponding to the user on the client device; wherein, when the command is executed on the client device, the client device transmits a request to the server (104) for the execution of the command on the server; wherein, upon receiving the request from the client device, the server executes a command using a copy of the state data stored on the server to verify the purchase transaction related to the purchase transaction request on the client device on the server, wherein the execution of the command by the server includes converting a command related to the client device into a server command executable on the server based on the logic code of the client device, and the verification of the purchase transaction by the server is based on converting a command written in one or more programming languages ​​into another programming language. and—a method comprising the step of allowing or preventing the purchase transaction by the server on the client device based on the execution of the command on the server. Claim 2 A method according to claim 1, wherein the execution of the command is based on verification that there is a sufficient resource balance to complete the purchase transaction, and the resource balance includes virtual currency or credits used in the game application. Claim 3 A method according to paragraph 2, wherein the purchase transaction is allowed if the sufficient resource balance exists in the copy of the state data on the server (104), and the purchase transaction is prevented if the sufficient resource balance does not exist in the copy of the state data on the server. Claim 4 In claim 1, the step of allowing or preventing the purchase transaction at the client device (102) by the server (104) comprises: generating a trust score for the user by the server based on at least one or more previous purchase transactions of the user; and verifying the purchase transaction based on the user's trust score. Claim 5 A method according to claim 1, wherein the resource comprises credits obtained by the user in the game application on the client device (102). Claim 6 A system (100) for verifying a purchase transaction in a game application in a client-server game environment, - a client device (102), - receiving a request for said purchase transaction from a user, - said purchase transaction includes exchanging resources to acquire assets by said user in said game application on said client device, - and - executing a command related to said purchase transaction request based on state data corresponding to the user on said client device; - a client device (102) configured to transmit a request for the execution of said command on said server (104) to said server (104) when said command is executed on said client device; A system comprising: a server coupled to communicate with the client device via a network; wherein, upon receiving the request from the client device, the server executes the command using a copy of state data stored in the server to verify the purchase transaction related to the purchase transaction request from the client device; wherein, to execute the command on the server, the server is configured to convert a command related to the client into a server command executable on the server based on the logic code of the client device, and the verification of the purchase transaction by the server is based on converting a command written in one programming language into another programming language; and wherein, based on the execution of the command on the server, the server is configured to perform at least one of allowing the purchase transaction or preventing the purchase transaction on the client device. Claim 7 In paragraph 6, the execution of the command is based on verification that there is a resource balance sufficient to complete the purchase transaction, and the resource balance includes virtual currency or credits used in the game application, the system. Claim 8 A system according to claim 7, wherein the purchase transaction is allowed if the sufficient resource balance exists in the copy of the status data on the server (104), and the purchase transaction is prevented if the sufficient resource balance does not exist in the copy of the status data on the server. Claim 9 In any one of claims 6 through 8, the server (104) is configured to: generate a trust score for the user based on at least one previous purchase transaction of the user; and verify the purchase transaction based on the user's trust score. Claim 10 A system according to any one of claims 6 through 8, wherein the resources include credits obtained by the user in the game application on the client device (102). Claim 11 A non-transient computer-readable storage medium for storing a computer program including computer-readable instructions, wherein the computer-readable instructions are executable by a computerized device including processing hardware that executes a method according to any one of claims 1 to 5. Claim 12 delete Claim 13 delete Claim 14 delete Claim 15 delete

Images