Method and system for allocating shared resources of a property based on blockchain storage

Abstract

This invention relates to the field of blockchain technology and discloses a method and system for allocating shared property resources based on blockchain notarization. The method includes: deploying an executable resource allocation contract for shared property resources on the blockchain; establishing a static allocation group for shared property resources within the executable resource allocation contract, wherein each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields; when a voting resolution on the blockchain is passed, writing the executable parameters from the voting resolution into the parameter fields to convert the static allocation group into an executable allocation group; running the executable allocation group using the executable resource allocation contract; and activating the next-order allocation group in the executable allocation group if the execution of the executable allocation group fails, thereby realizing the allocation of shared property resources. This invention can automatically execute voting resolutions on the blockchain, complete resource transfers without manual intervention, and synchronously update on-chain information.

Description

Technical Field

[0001] This invention relates to a method and system for allocating shared property resources based on blockchain-based evidence storage, and belongs to the field of blockchain technology. Background Technology

[0002] Currently, after the property management of a residential community enters the basic information of resources such as shared parking spaces into the blockchain, the owners can form an allocation decision through on-chain voting. However, the voting result is only a text record on the blockchain. Subsequently, the decision on which specific resource to allocate, how to change the holder, and how to update the on-chain data still require manual operation by the administrator. For example, manually searching for the corresponding parking space, manually modifying the holder information of the parking space, and then uploading the new data to the blockchain. This method is not only time-consuming and error-prone, but also leaves room for human intervention, resulting in an opaque and difficult-to-audit allocation process, and failing to truly leverage the advantages of blockchain's automatic trustworthiness.

[0003] Therefore, existing technologies lack a mechanism that can automatically execute voting decisions on-chain, complete resource transfers without human intervention, and synchronously update on-chain information. Summary of the Invention

[0004] This invention provides a method and system for allocating shared property resources based on blockchain evidence storage. Its main purpose is to automatically execute voting decisions on the blockchain, complete resource transfers without human intervention, and synchronously update on-chain information.

[0005] To achieve the above objectives, the present invention provides a property shared resource allocation method based on blockchain notarization, comprising: Deploy executable resource allocation contracts for shared property resources on the blockchain; Within the executable resource allocation contract, a static allocation group for the shared property resources is established, wherein each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields; Once the voting resolution on the blockchain is passed, the executable parameters in the voting resolution are written into the parameter field to convert the static allocation group into an executable allocation group. When the allocation of the shared property resources expires, the executable allocation group is run using the executable resource allocation contract; If the execution of the executable allocation group fails, the next priority allocation group of the executable allocation group is activated to realize the allocation process of the property shared resources.

[0006] Optionally, deploy executable resource allocation contracts for shared property resources on the blockchain, including: Upload bytecode to the blockchain to establish an instantiated contract on the blockchain; Write the resource identifier, current holder address, and lease start and end times of the shared property resources into the instantiated contract, and create an expandable empty array to deploy an executable resource allocation contract.

[0007] Optionally, a static allocation group for the shared property resources may be established within the executable resource allocation contract, including: The allocation rule structures are pushed into an expandable empty array according to priority to establish a static allocation group; each allocation rule structure has a preset rule type, trigger time, target user address, execution conditions and parameter fields.

[0008] Optionally, the executable parameters in the voting resolution are written into the parameter field, including: Use the voting contract in the blockchain to invoke the resolution parser; The resolution parser extracts executable parameters from the voting resolution. Call the update parameter function of the executable resource allocation contract; The executable parameters are written into the parameter field using the update parameter function.

[0009] Optionally, running the executable allocation group using the executable resource allocation contract includes: Trigger the state change event of the executable allocation group; Based on the trigger time corresponding to the state change event, the highest priority allocation rule structure is run using the executable resource allocation contract to run the executable allocation group.

[0010] Optionally, the executable resource allocation contract is used to run the highest priority allocation rule structure, including: After marking the highest priority allocation rule structure as activated in the contract state database, a renewal transaction request with a countdown condition is initiated to the target user address of the highest priority allocation rule structure to run the highest priority allocation rule structure.

[0011] Optionally, the countdown condition is set by reading the parameter field of the highest priority allocation rule structure, and the remaining time counter of the countdown condition is maintained by an executable resource allocation contract.

[0012] Optionally, activating the next priority allocation group of the executable allocation group includes: The highest priority allocation rule structure is deleted from the blockchain by executing the automatic destruction instruction of the resource allocation contract, thereby releasing the priority sequence number of the highest priority allocation rule structure. After releasing the priority number of the highest priority allocation rule structure, the next priority allocation group of the executable allocation group is activated.

[0013] Optionally, activating the next priority allocation group of the executable allocation group includes: The next sequential allocation group of the executable allocation group is selected according to the array index incrementing method; A countdown renewal process is performed on the next priority allocation group until the shared property resources corresponding to the next priority allocation group are successfully allocated or the array is traversed.

[0014] To address the aforementioned problems, this invention also provides a property shared resource allocation system based on blockchain-based evidence storage, the system comprising: The contract deployment module is used to deploy executable resource allocation contracts for shared property resources on the blockchain; The allocation group creation module is used to create a static allocation group for the shared property resources within the executable resource allocation contract. Each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields. The parameter writing module is used to write the executable parameters in the voting resolution into the parameter field after the voting resolution on the blockchain is passed, so as to convert the static allocation group into an executable allocation group. The allocation group operation module is used to run the executable allocation group using the executable resource allocation contract when the allocation of the shared property resources expires. The resource allocation module is used to activate the next priority allocation group of the executable allocation group when the execution of the executable allocation group fails, so as to realize the allocation processing of the shared property resources.

[0015] Compared to the problems described in the background technology, this embodiment of the invention deploys an executable resource allocation contract on the blockchain, enabling the executable resource allocation contract to have a built-in blank rule card. This blank rule card automatically fills in data when new shared resource data appears, ensuring that subsequent allocations do not require manual table creation or re-uploading of rules. Furthermore, this embodiment of the invention establishes a static allocation group for the shared property resources within the executable resource allocation contract, solidifying the rule type, trigger time, target user, and parameter fields into an on-chain structure array, providing slots for parameter injection after voting, achieving simultaneous and tamper-proof storage of rules and resources on the same chain. Furthermore, this embodiment of the invention writes the executable parameters from the voting resolution into the parameter field. In order to ensure that the conversion from text to machine instructions is completed within the same transaction, eliminate manual data modification, and ensure that on-chain data is consistent with the community's will in real time, this invention further ensures that when resources expire, the contract automatically runs an executable allocation group, and automatically retrieves the highest priority rule and initiates a countdown renewal at the moment the block time arrives. The entire process is driven on-chain and does not require offline intervention. Furthermore, this invention further ensures that if the operation fails, the current rule is destroyed and the next priority is activated, so as to realize automatic waiting and replacement within the chain, ensuring that resources are not idle and that the entire process is auditable. This solves the problems of gaps in voting and implementation due to human intervention and update lag. Therefore, this invention can automatically execute voting decisions on the chain, complete resource transfer and synchronously update on-chain information without human intervention. Attached Figure Description

[0016] Figure 1 A schematic flowchart of a property shared resource allocation method based on blockchain evidence storage provided in an embodiment of the present invention; Figure 2 A schematic diagram of the process for establishing a static allocation group in implementing the blockchain-based property shared resource allocation method according to an embodiment of the present invention; Figure 3 A schematic diagram of modules for implementing the blockchain-based property shared resource allocation method according to an embodiment of the present invention; Figure 4 A schematic diagram of a computer device for a property shared resource allocation method based on blockchain evidence storage, as provided in an embodiment of the present invention; The objectives, features, and advantages of this invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0017] It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

[0018] This application provides a method for allocating shared property resources based on blockchain-based evidence storage. The executing entity of this method includes, but is not limited to, at least one of the following electronic devices that can be configured to execute the method provided in this application: a server, a terminal, etc. In other words, the method for allocating shared property resources based on blockchain-based evidence storage can be executed by software or hardware installed on a terminal device or a server device. The server includes, but is not limited to, a single server, a server cluster, a cloud server, or a cloud server cluster.

[0019] Reference Figure 1 The diagram shown is a flowchart illustrating a property shared resource allocation method based on blockchain evidence storage according to an embodiment of the present invention. In this embodiment, the property shared resource allocation method based on blockchain evidence storage includes: S1. Deploy executable resource allocation contracts for shared property resources on the blockchain.

[0020] This invention deploys an executable resource allocation contract on the blockchain, which comes with a blank rule card. This blank rule card will automatically fill in data when new shared resource data appears, ensuring that subsequent allocations do not require manual table creation or re-uploading of rules.

[0021] The blockchain refers to a decentralized distributed ledger system that stores data in chronological order, is publicly verifiable, and is tamper-proof. The executable resource allocation contract refers to a smart contract with state storage and logic execution capabilities, used to receive external calls and automatically complete the resource allocation process. The shared property resources refer to community public facilities owned by the owners and available for rotation, including parking spaces, storage rooms, charging piles, etc.

[0022] In one embodiment of the present invention, the step of deploying an executable resource allocation contract for shared property resources on a blockchain includes: uploading bytecode to the blockchain to establish an instantiated contract on the blockchain; writing the resource identifier of the shared property resources, the current holder's address, and the lease start and end times into the instantiated contract, and establishing an expandable empty array to deploy the executable resource allocation contract.

[0023] The bytecode refers to the compiled form of the smart contract, the uploaded content directly executed by the blockchain virtual machine. The resource identifier is a number or string used to uniquely identify each shared resource, written into the contract for subsequent rule matching. The current holder address is the blockchain account address, recording the user currently holding the right to use it, used for identity verification during renewal or replacement. The lease start and end time refers to the start and end times of the right to use, recorded in the form of block timestamps, triggering an automatic reassignment process upon expiration. The expandable empty array is a blank array whose length can be dynamically increased during contract initialization, subsequently used to sequentially store the allocation rule structure, ensuring that the number of rules can freely increase or decrease as voting changes.

[0024] Optionally, the process of uploading bytecode to the blockchain is as follows: the bytecode is sent to the chain as transaction data, and permanently stored after confirmation by network nodes. Further, the process of establishing an instantiated contract on the blockchain is as follows: after the bytecode is uploaded, the blockchain virtual machine assigns a unique address to it and initializes storage space to form a callable and storable contract instance. Further, the process of writing the resource identifier, current holder address, and lease start and end time of the shared property resources and establishing an expandable empty array in the instantiated contract is as follows: the above field values ​​are permanently stored in the contract storage area, which can be read by any external call and cannot be tampered with. The process of deploying the executable resource allocation contract is as follows: after completing the bytecode upload, field writing, and empty array establishment, the contract has all the functions of automatically executing resource allocation, that is, an executable resource allocation contract is obtained.

[0025] S2. Establish a static allocation group for the shared property resources within the executable resource allocation contract, wherein each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields.

[0026] This invention establishes a static allocation group for the shared property resources within the executable resource allocation contract, solidifies the rule type, trigger time, target user, and parameter fields into an on-chain structure array, provides a slot for parameter injection after voting, and realizes that the rules and resources are stored on the same chain and cannot be tampered with.

[0027] The static allocation group refers to a set of rules created within the executable resource allocation contract, used to pre-set various conditions for resource allocation. At this point, the rules have not yet been injected with specific parameters, hence the term "static." The array element refers to a single entry within the static allocation group, stored sequentially, with priority determined by the array index. The rule type refers to an enumeration value used to distinguish different allocation strategies such as priority renewal, sequential replacement, and public bidding. The trigger time refers to the block timestamp, indicating the earliest time when the rule can be activated, such as 7 days before the lease expires. The target user address refers to a list of blockchain accounts that will receive renewal or allocation notifications when the rule takes effect. The execution condition refers to a Boolean expression used to determine whether the user meets requirements such as response time and payment amount. The parameter field refers to a blank storage area reserved for subsequent voting, initially empty, for injecting executable parameters such as renewal duration and discount rate.

[0028] In one embodiment of the present invention, establishing a static allocation group for the shared property resources within the executable resource allocation contract includes: pushing allocation rule structures into an expandable empty array according to priority order to establish a static allocation group; wherein each allocation rule structure has preset rule type, trigger time, target user address, execution conditions, and parameter fields.

[0029] The priority order refers to the order in which the smaller the array index, the higher the priority. Subsequent contracts start searching from the 0th position, and the rules pushed in first are executed first. The allocation rule structure refers to a single entry in the array, which contains all the judgment fields required for subsequent automatic allocation.

[0030] Optionally, the process of pushing allocation rule structures into the expandable empty array according to priority order is: appending a complete allocation rule structure to the end of the array.

[0031] See Figure 2 The diagram shown illustrates the process of establishing a static allocation group in an embodiment of the blockchain-based property shared resource allocation method according to an embodiment of the present invention. Figure 2 In the first row, from left to right, the bytecode is uploaded, the contract is instantiated, and the resource ID, holder, and start and end times are written. The rightmost row, from top to bottom, contains the resource ID, holder, and start and end times, an empty array is created, and the rule structure is pushed in according to priority to form a static allocation group.

[0032] S3. After the voting resolution on the blockchain is passed, the executable parameters in the voting resolution are written into the parameter field to convert the static allocation group into an executable allocation group.

[0033] It should be noted that when a voting resolution on the blockchain is passed, it means that the owner's on-chain voting has reached a preset threshold, forming a binding decision text.

[0034] Furthermore, in this embodiment of the invention, the executable parameters in the voting resolution are written into the parameter field to ensure that the conversion from text to machine instructions is completed within the same transaction, thereby eliminating manual modification of data and ensuring that on-chain data is consistent with the community's will in real time.

[0035] The executable parameters refer to specific values ​​or conditions extracted from the resolution text, such as renewal duration, discount rate, countdown days, etc., which can be directly read and calculated by the contract.

[0036] In one embodiment of the present invention, writing the executable parameters in the voting resolution into the parameter field includes: calling a resolution parser using a voting contract in the blockchain; extracting executable parameters from the voting resolution through the resolution parser; calling the update parameter function of the executable resource allocation contract; and writing the executable parameters into the parameter field using the update parameter function.

[0037] The voting contract refers to the smart contract responsible for initiating and counting owner votes. Once the vote is passed, it immediately issues a call instruction to the outside world. The resolution parser refers to the on-chain program that receives the voting contract instruction and is used to extract executable values ​​such as renewal duration and discount rate from the resolution text. The update parameter function refers to the only write interface exposed by the executable resource allocation contract. It can only be called by the parser and is used to fill the extracted values ​​into the previously empty parameter fields.

[0038] Optionally, the process of writing the executable parameters into the parameter field using the update parameter function is as follows: by calling the update parameter function of the executable resource allocation contract, the above values ​​are filled into the previously empty parameter field, so that the original static rule obtains specific execution conditions.

[0039] Optionally, the process of converting the static allocation group into an executable allocation group is as follows: after parameter injection, the rules change from templates to immediately executable instructions, and the contract can subsequently automatically initiate countdowns, calculate prices, and determine success or failure based on these values.

[0040] S4. When the allocation of the shared property resources expires, the executable allocation group is run using the executable resource allocation contract.

[0041] It should be noted that when the allocation of the shared property resources expires, it means that the blockchain's block timestamp has reached or exceeded the pre-written lease end time. This moment serves as the recognized expiration judgment benchmark on the chain, triggering the subsequent automatic allocation process.

[0042] Furthermore, in this embodiment of the invention, when resources expire, the contract automatically runs an executable allocation group, and the highest priority rule is automatically retrieved and a countdown renewal is initiated at the moment the block time arrives. The entire process is driven on-chain and does not require offline intervention.

[0043] In one embodiment of the present invention, the step of running the executable allocation group using the executable resource allocation contract includes: triggering a state change event of the executable allocation group; and, based on the triggering time corresponding to the state change event, running the highest priority allocation rule structure using the executable resource allocation contract to run the executable allocation group.

[0044] The state change event refers to an event notification issued internally by the contract when the block timestamp reaches or exceeds the end time, changing the resource status from "in use" to "pending allocation" and unlocking the subsequent rule retrieval process. The trigger time of the state change event is based on the block timestamp at the moment of the state change. After this moment, the executable resource allocation contract immediately scans the executable allocation group to determine which rules have met the condition that the trigger time is less than or equal to the current time, thereby determining the set of rules that can participate in this round of execution. In this set of rules, the rules that meet the conditions first are retrieved according to the array index order. This rule represents the highest priority allocation rule structure.

[0045] In another embodiment of the present invention, the step of running the highest priority allocation rule structure using the executable resource allocation contract includes: after marking the highest priority allocation rule structure as activated in the contract state database, initiating a renewal transaction request with countdown conditions to the target user address of the highest priority allocation rule structure to run the highest priority allocation rule structure.

[0046] The contract state library refers to the area on the blockchain where smart contracts permanently store data, used to record state information such as flags, timestamps, and arrays. It can be read and cannot be tampered with by any external call. The activated state refers to the internal flag of the contract, used to lock the current rules and prevent concurrent or repeated execution. The countdown condition refers to the duration value read from the parameter field, which determines how many seconds the user must complete the renewal confirmation. The renewal transaction request refers to the on-chain message sent out by the contract, which includes information such as the countdown duration and renewal price. The renewal process is automatically completed after the user confirms.

[0047] Optionally, the process of using the executable resource allocation contract to run the highest priority allocation rule structure is as follows: for the highest priority allocation rule structure, its built-in logic is called to initiate a countdown renewal request to the target user, thus completing the actual operation of the executable allocation group. Further, the process of running the highest priority allocation rule structure is as follows: the contract sequentially completes the entire process of marking, sending requests, counting down, and verifying results, realizing the complete lifecycle of the rule from activation to result determination.

[0048] In another embodiment of the present invention, the countdown condition is set by reading the parameter field of the highest priority allocation rule structure, and the remaining time counter of the countdown condition is maintained by an executable resource allocation contract.

[0049] The remaining time counter refers to a decrementing variable maintained on-chain by the executable resource allocation contract. It decreases by one unit per second to reflect the current remaining time in real time. When the value reaches zero, the contract determines that the countdown has ended and triggers subsequent processing.

[0050] S5. If the execution of the executable allocation group fails, activate the next priority allocation group of the executable allocation group to realize the allocation processing of the property shared resources.

[0051] When the execution of the executable allocation group fails, it means that the highest priority allocation rule structure has not received a valid renewal confirmation from the target user within the set countdown. Based on this, the contract determines that the rule execution has failed and triggers the subsequent replacement process.

[0052] Furthermore, this embodiment of the invention achieves automatic waiting list filling within the chain by destroying the current rule and activating the next priority if the operation fails, ensuring that resources are not left idle and that the entire process is auditable, thereby solving the problems of human intervention and update lag in voting and implementation gaps.

[0053] In one embodiment of the present invention, activating the next priority allocation group of the executable allocation group includes: deleting the highest priority allocation rule structure from the blockchain through an automatic destruction instruction of the executable resource allocation contract to release the priority number of the highest priority allocation rule structure; and activating the next priority allocation group of the executable allocation group after releasing the priority number of the highest priority allocation rule structure.

[0054] The automatic destruction instruction refers to the on-chain deletion command built into the executable resource allocation contract. After execution, the highest priority allocation rule structure is immediately removed from the blockchain storage and its occupied priority sequence number is released.

[0055] Optionally, the process of deleting the highest priority allocation rule structure from the blockchain is as follows: the structure bytecode and state are permanently cleared to ensure that the rule will no longer participate in any subsequent allocation process. Furthermore, the process of releasing the priority sequence number of the highest priority allocation rule structure is as follows: the sorting position occupied by the original rule is vacated, and the contract can immediately promote the next priority rule to the new highest priority to ensure that the replacement order is correct.

[0056] In another embodiment of the present invention, activating the next priority allocation group of the executable allocation group includes: selecting the next priority allocation group of the executable allocation group in ascending order of array subscripts; performing countdown renewal processing on the next priority allocation group until the property shared resources corresponding to the next priority allocation group are successfully allocated or the array traversal is completed.

[0057] The array index increment method refers to starting from the index of the currently deleted rule plus 1, and selecting the next rule structure in sequence to ensure that the priority is filled in order from high to low. The next priority allocation group refers to the selected new rule structure, which already contains the trigger time, target user address and countdown parameters, and can be put into execution immediately.

[0058] Optionally, the process of performing countdown renewal processing on the next priority allocation group is as follows: start an on-chain countdown for the structure with the same rules as the previous rule, send a renewal request to the target user, and maintain a remaining time counter. Further, the process until the property shared resources corresponding to the next priority allocation group are successfully allocated or the array is traversed is as follows: if the user confirms and pays on time, the contract terminates the replacement process, and the right to use the resource is transferred. If no one responds when the countdown reaches the last rule, the contract determines that all rules are exhausted, the resource enters the state of waiting to be relisted, and the automatic allocation of this round ends.

[0059] like Figure 3 The diagram shown is a functional module diagram of the property shared resource allocation system based on blockchain evidence storage according to the present invention.

[0060] The blockchain-based property shared resource allocation system 300 described in this invention can be installed in an electronic device. Depending on its functions, the blockchain-based property shared resource allocation system includes a contract deployment module 301, an allocation group establishment module 302, a parameter writing module 303, an allocation group operation module 304, and a resource allocation module 305. The module described in this invention can also be called a unit, which refers to a series of computer program segments that can be executed by the processor of an electronic device and perform a fixed function, stored in the memory of the electronic device.

[0061] In this embodiment of the invention, the functions of each module / unit are as follows: The contract deployment module 301 is used to deploy executable resource allocation contracts for shared property resources on the blockchain; The allocation group establishment module 302 is used to establish a static allocation group for the shared property resources within the executable resource allocation contract. Each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields. The parameter writing module 303 is used to write the executable parameters in the voting resolution into the parameter field after the voting resolution on the blockchain is passed, so as to convert the static allocation group into an executable allocation group. The allocation group operation module 304 is used to run the executable allocation group using the executable resource allocation contract when the allocation of the property shared resources expires. The resource allocation module 305 is used to activate the next priority allocation group of the executable allocation group when the execution of the executable allocation group fails, so as to realize the allocation processing of the property shared resources.

[0062] In detail, the modules in the blockchain-based property shared resource allocation system 300 described in this embodiment of the invention employ the same methods as described above. Figure 1 The method used here is the same as the blockchain-based property resource sharing allocation method described above, and it can produce the same technical effect, so it will not be elaborated here.

[0063] In one embodiment, a computer device is provided, which may be a server or a client, and its internal structure diagram may be as follows: Figure 4 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The network interface is used to communicate with external clients via a network connection. When the computer program is executed by the processor, it implements the functions or steps of a blockchain-based property sharing resource allocation method on the server or client side.

[0064] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps: Deploy executable resource allocation contracts for shared property resources on the blockchain; Within the executable resource allocation contract, a static allocation group for the shared property resources is established, wherein each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields; Once the voting resolution on the blockchain is passed, the executable parameters in the voting resolution are written into the parameter field to convert the static allocation group into an executable allocation group. When the allocation of the shared property resources expires, the executable allocation group is run using the executable resource allocation contract; If the execution of the executable allocation group fails, the next priority allocation group of the executable allocation group is activated to realize the allocation process of the property shared resources.

[0065] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program performing the following steps when executed by a processor: Deploy executable resource allocation contracts for shared property resources on the blockchain; Within the executable resource allocation contract, a static allocation group for the shared property resources is established, wherein each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields; Once the voting resolution on the blockchain is passed, the executable parameters in the voting resolution are written into the parameter field to convert the static allocation group into an executable allocation group. When the allocation of the shared property resources expires, the executable allocation group is run using the executable resource allocation contract; If the execution of the executable allocation group fails, the next priority allocation group of the executable allocation group is activated to realize the allocation process of the property shared resources.

[0066] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and client side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0067] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory may include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory may include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), RAMbus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0068] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0069] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential characteristics of the present invention.

[0070] Finally, it should be noted that in the above embodiments, each embodiment can be combined with each other or independent. Deleting any one of them will not affect the technical implementation of other embodiments. The above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention.

Claims

1. A method for allocating shared property resources based on blockchain-based evidence storage, characterized in that: The method includes: Deploy executable resource allocation contracts for shared property resources on the blockchain; Within the executable resource allocation contract, a static allocation group for the shared property resources is established, wherein each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields; Once the voting resolution on the blockchain is passed, the executable parameters in the voting resolution are written into the parameter field to convert the static allocation group into an executable allocation group. When the allocation of the shared property resources expires, the executable allocation group is run using the executable resource allocation contract; If the execution of the executable allocation group fails, the next priority allocation group of the executable allocation group is activated to realize the allocation process of the property shared resources.

2. The method for allocating shared property resources based on blockchain evidence storage as described in claim 1, characterized in that, Deploying executable resource allocation contracts for shared property resources on a blockchain includes: Upload bytecode to the blockchain to establish an instantiated contract on the blockchain; Write the resource identifier, current holder address, and lease start and end times of the shared property resources into the instantiated contract, and create an expandable empty array to deploy an executable resource allocation contract.

3. The method for allocating shared property resources based on blockchain evidence storage as described in claim 2, characterized in that, Within the executable resource allocation contract, a static allocation group for the shared property resources is established, including: The allocation rule structures are pushed into an expandable empty array according to priority to establish a static allocation group; each allocation rule structure has a preset rule type, trigger time, target user address, execution conditions and parameter fields.

4. The method for allocating shared property resources based on blockchain evidence storage as described in claim 1, characterized in that, Write the executable parameters from the voting resolution into the parameter field, including: Use the voting contract in the blockchain to invoke the resolution parser; The resolution parser extracts executable parameters from the voting resolution. Call the update parameter function of the executable resource allocation contract; The executable parameters are written into the parameter field using the update parameter function.

5. The method for allocating shared property resources based on blockchain evidence storage as described in claim 1, characterized in that, Running the executable allocation group using the executable resource allocation contract includes: Trigger the state change event of the executable allocation group; Based on the trigger time corresponding to the state change event, the highest priority allocation rule structure is run using the executable resource allocation contract to run the executable allocation group.

6. The method for allocating shared property resources based on blockchain evidence storage as described in claim 5, characterized in that, Running the highest priority allocation rule structure using the executable resource allocation contract includes: After marking the highest priority allocation rule structure as activated in the contract state database, a renewal transaction request with a countdown condition is initiated to the target user address of the highest priority allocation rule structure to run the highest priority allocation rule structure.

7. The method for allocating shared property resources based on blockchain evidence storage as described in claim 6, characterized in that, The countdown condition is set by reading the parameter field of the highest priority allocation rule structure, and the remaining time counter of the countdown condition is maintained by an executable resource allocation contract.

8. The method for allocating shared property resources based on blockchain evidence storage as described in claim 1, characterized in that, Activating the next priority allocation group of the executable allocation group includes: The highest priority allocation rule structure is deleted from the blockchain by executing the automatic destruction instruction of the resource allocation contract, thereby releasing the priority sequence number of the highest priority allocation rule structure. After releasing the priority number of the highest priority allocation rule structure, the next priority allocation group of the executable allocation group is activated.

9. The method for allocating shared property resources based on blockchain evidence storage as described in claim 8, characterized in that, Activating the next priority allocation group of the executable allocation group includes: The next sequential allocation group of the executable allocation group is selected according to the array index incrementing method; A countdown renewal process is performed on the next priority allocation group until the property shared resources corresponding to the next priority allocation group are successfully allocated or the array is traversed.

10. A property shared resource allocation system based on blockchain-based evidence storage, characterized in that: The system includes: The contract deployment module is used to deploy executable resource allocation contracts for shared property resources on the blockchain; The allocation group creation module is used to create a static allocation group for the shared property resources within the executable resource allocation contract. Each array element in the static allocation group includes a rule type, trigger time, target user address, execution conditions, and parameter fields. The parameter writing module is used to write the executable parameters in the voting resolution into the parameter field after the voting resolution on the blockchain is passed, so as to convert the static allocation group into an executable allocation group. The allocation group operation module is used to run the executable allocation group using the executable resource allocation contract when the allocation of the shared property resources expires. The resource allocation module is used to activate the next priority allocation group of the executable allocation group when the execution of the executable allocation group fails, so as to realize the allocation processing of the property shared resources.

Images