Blockchain-based method for digital copyright registration of artwork

Abstract

The application discloses a blockchain-based art digital copyright registration method, and particularly relates to the technical field of digital copyright protection, and comprises the following steps: firstly, a blind fingerprint of an artwork is calculated, and a placeholder hash is generated and written into a blockchain; subsequently, a reveal window is opened after a delay controlled by a verifiable random function, and the fingerprint and metadata are submitted; when the similarity of the revealed work is too high, a congestion signal is generated, a dynamic threshold adjustment is triggered, and deep and fine similarity is obtained; based on the comparison result, the fingerprint is merged into a cluster, and after the reveal is completed, the original and derivative artworks are confirmed according to the detail score, a trusted copyright relationship is established; the application realizes the non-tamperable copyright of the artwork information, ensures that the registration order is verifiable, improves the similarity identification accuracy through dynamic threshold adjustment and off-chain fine comparison, and automatically establishes the original and derivative relationship through the clustering and detail scoring mechanism, so that the copyright ownership is clear and traceable.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of digital copyright protection, more particularly, the present application relates to an art digital copyright registration method based on a blockchain. BACKGROUND

[0002] With the widespread deployment of image generation artificial intelligence models, especially the trend of decentralized AI painting platforms based on diffusion models and generative adversarial networks, a large number of image content can be generated on a large scale within seconds and automatically published through an on-chain mechanism. Such platforms usually use a real-time on-chain mechanism, that is, each generated image is immediately written into the chain after generation to achieve "first-occupying" registration protection of the ownership of the work. However, in a public chain structure, this mechanism has caused serious copyright confusion problems.

[0003] For example, under a specific social hot topic, an AI drawing generator generates thousands of highly similar images in a very short time and uploads and writes them into the blockchain through a smart contract. At that time, some human artists were still in the process of creating or had not completed the scanning process, causing the high-resolution image on-chain time to be "AI-generated image" to be preempted, forming a "reversal of timestamp" factual misplacement.

[0004] Because most existing smart contracts use the logic of "first come, first registered, first ownership", the system automatically identifies AI-generated images as original registered works, and the works of human artists are considered as repeated registration or even infringement. This process is often automatically executed by an on-chain crawler without human review, resulting in the fingerprint of a legitimate original work being permanently covered or marked as non-original, making it impossible to establish rights on the chain. More seriously, once the AI-generated image spreads virally on social media, even if the artist can prove that he owns the original work, he still needs to go through a long and costly off-chain judicial or arbitration process to claim it. However, the on-chain status of copyright ownership is irreversible, and the real author almost loses the possibility of timely rights protection under the unalterable timestamp recording mechanism.

[0005] Such an attack is called "AI generator crazy writing copyright insertion attack", which is essentially a copyright pre-emption behavior created by taking advantage of the upload delay and the blind area of smart contract rules. Existing blockchain notarization solutions lack the ability to judge the similarity of image content, the complexity of visual details, and originality, and can only use time as the criterion for ownership determination, making it difficult to establish an original derivative structure relationship between multiple subjects simultaneously registered and highly similar images, and even more difficult to cope with the systematic congestion caused by the "high-density aggregation" of image fingerprints in a short time. Therefore, the present application proposes an art digital copyright registration method based on a blockchain to solve the above problems. SUMMARY

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] The blockchain-based digital copyright registration method for artworks includes the following steps:

[0008] The registration node calculates a blinded fingerprint for the artwork to be registered, combines the blinded fingerprint with a random salt value to generate a placeholder hash, and writes it along with a trusted timestamp into the blockchain to complete the registration placeholder.

[0009] The smart contract determines the delay time based on a verifiable random function. When the delay expires, a disclosure window is opened. The registered node submits the complete fingerprint, random salt value and artwork metadata corresponding to the placeholder hash in the disclosure window.

[0010] During the reveal window, the smart contract statistically analyzes the similarity distribution among revealed fingerprints in real time, and generates a congestion signal when the number of similar fingerprints exceeds a preset threshold.

[0011] After generating the congestion signal, the smart contract immediately lowers the dynamic similarity threshold and calls the off-chain multi-scale deep feature comparison algorithm to obtain the fine similarity evaluation results between fingerprints.

[0012] Based on the results of the fine similarity evaluation, the smart contract groups fingerprints with a similarity of not less than the dynamic similarity threshold into the same fingerprint cluster and generates a unique cluster identifier for each fingerprint cluster.

[0013] When the reveal window ends, the smart contract sorts the artworks in each fingerprint cluster based on multi-scale detail scores, registers the artwork with the highest detail score as the original artwork, and registers other artworks in the same cluster as derivative artworks and establishes a relationship between them.

[0014] In a preferred embodiment, the calculation of the blinded fingerprint includes the following steps:

[0015] The registration node preprocesses the digital image of the artwork to be registered according to a fixed resolution and a unified color space, and performs high-frequency noise suppression on the pixel matrix to eliminate the interference of scanning device noise on fingerprint stability;

[0016] The registration node constructs a multi-scale discrete cosine transform feature vector based on the preprocessed pixel matrix, and inputs the feature vector into a one-way key hash function based on the artwork's private key to generate a privacy-preserving feature string;

[0017] The registration node applies a reversible quantization perturbation algorithm to the privacy-preserving feature string, reducing the probability of single-point pixel reconstruction while maintaining global perception consistency, thus obtaining a blind fingerprint that is both publicly verifiable and difficult to reverse-restore.

[0018] The blind fingerprint obtained through the above three steps has both uniqueness and collision resistance, providing a secure fingerprint basis for subsequent occupancy operations.

[0019] In a preferred embodiment, the generation and writing of placeholder hashes includes the following steps:

[0020] The registration node randomly generates an encrypted random salt value that matches the length of the blinded fingerprint, and concatenates the blinded fingerprint and the random salt value in a preset order to form the original string to be hashed;

[0021] The registration node uses the Secure Hash Algorithm Version 3 to calculate a fixed-length hash of the original string to be hashed, obtains a placeholder hash, and synchronously requests a trusted timestamp signature from the distributed timestamp authority.

[0022] The registering node writes the placeholder hash, random salt value and its trusted timestamp as an indivisible data packet into the blockchain transaction payload and broadcasts it to the network. The placeholder record is immutable when the first confirmed block is generated.

[0023] The placeholder operation implemented through the above three steps ensures that any subsequent registration request must reference the same blinded fingerprint and random salt value combination, avoiding originality disputes caused by the generator's massive insertion casting.

[0024] In a preferred embodiment, the process of determining the delay time based on a verifiable random function includes the following steps:

[0025] After receiving the placeholder hash, the smart contract calls the block header random number, the node key commitment value and the current network difficulty to form the input seed, which provides multi-source entropy for the verifiable random function.

[0026] The smart contract puts the input seed into a verifiable random function based on the elliptic curve digital signature algorithm, outputs a pseudo-random number that is unpredictable for any single node and can be publicly verified, and generates zero-knowledge proofs simultaneously.

[0027] The smart contract obtains the delay time by linearly mapping pseudo-random numbers within a preset shortest and longest delay interval, and writes the delay time and zero-knowledge proof into the blockchain for external nodes to verify. The disclosure window is automatically opened after the delay expires.

[0028] In a preferred embodiment, the process of generating the input seed includes the following steps:

[0029] The smart contract reads the random number segment of the header of the most recently agreed-upon block immediately after the placeholder hash is written, and broadcasts the random number through the event log so that any node can trace and verify it.

[0030] Before entering the next block production cycle, the block validator calculates a secure hash using a one-time public key to obtain the node key commitment value, and submits it along with its digital signature to the on-chain key commitment registration contract. The smart contract verifies and immediately publishes the commitment value.

[0031] The smart contract continuously retrieves the difficulty field of several latest blocks within a preset window, calculates the moving average to form the current network difficulty, and writes it to the state storage along with the timestamp.

[0032] In a preferred embodiment, the process of generating a congestion signal includes the following steps:

[0033] The smart contract performs a discrete cosine transform on each pair of fingerprints within the same block after four levels of scaling, extracts the bit strings and calculates the Hamming distance, and generates a multi-scale sensing distance list.

[0034] Using the most recent n revealed records as a window, fingerprints with a distance lower than the current similarity threshold are marked as similar, and the similarity count within the window is counted.

[0035] Calculate the average similarity count of the first m windows, and use the reciprocal of the product of this average and the preset safety factor as the new threshold after dynamic tightening;

[0036] A congestion signal is triggered when the similarity count in the current window exceeds a new threshold.

[0037] In a preferred embodiment, the process of immediately reducing the dynamic similarity threshold and obtaining fine-grained similarity evaluation results between fingerprints after generating the congestion signal includes the following steps:

[0038] After a congestion signal is triggered, the smart contract multiplies a preset similarity threshold by a preset contraction coefficient to generate a contraction threshold and immediately updates the global state.

[0039] The smart contract simultaneously broadcasts the list of fingerprints to be evaluated and the shrinking threshold to the off-chain feature comparison service, along with a random challenge value to ensure that the returned results are verifiable;

[0040] After receiving the instruction, the off-chain comparison service extracts deep features using a multi-scale convolutional network, calculates the cosine distance between fingerprints, and returns a fine similarity matrix with zero-knowledge proofs.

[0041] After the smart contract verifies that the zero-knowledge proof is correct, the fine similarity matrix is ​​written into the fingerprint cluster mapping table for subsequent originality confirmation.

[0042] In a preferred embodiment, grouping fingerprints with a similarity of not less than the dynamic similarity threshold into the same fingerprint cluster means:

[0043] After receiving the fine similarity matrix, the smart contract maps fingerprint pairs with similarity higher than the dynamic similarity threshold, i.e. the shrinkage threshold, to edges in the graph structure and constructs a similarity graph in real time.

[0044] The smart contract calls the on-chain disjoint-setup algorithm on the similar graph to merge connected nodes from bottom to top. After each merge, the fingerprint with the highest weight is automatically selected as the cluster root of the connected component based on the edge weight.

[0045] The smart contract calculates a secure hash by combining the current block number and random entropy for each cluster root fingerprint, generating a unique cluster identifier, and stores the cluster identifier and all fingerprints within the cluster in a state table through a bidirectional mapping.

[0046] In a preferred embodiment, registering the artwork with the highest detail score as an original artwork means:

[0047] The smart contract performs a three-level discrete wavelet decomposition on the complete fingerprint within each fingerprint cluster, calculates the detail energy of each level, and summarizes it into a multi-scale detail score according to preset weights.

[0048] The smart contract sorts the cluster members from high to low according to the multi-scale detailed scores. If the difference between the highest score and the second highest score is less than the threshold, visual entropy comparison is added to determine the unique first and second place.

[0049] The smart contract registers the top-ranked artwork as the original artwork and writes the derivative relationship for the remaining artworks in the same cluster in the state mapping table, recording the original identifier, derivative level and timestamp.

[0050] The technical effects and advantages of this invention are as follows:

[0051] This invention establishes a copyright prioritization and registration order immutability mechanism by writing placeholder hashes and trusted timestamps into the blockchain. In the proposed registration process, the registration node first calculates a blinded fingerprint of the artwork to be registered and generates a placeholder hash by combining it with a random salt value. Simultaneously, a trusted timestamp is written into the blockchain, completing the irreversible initial placeholder. Through these operations, the copyright information of the artwork is confirmed on the blockchain at a specific point in time, effectively preventing ownership disputes caused by unclear copyright claim order or information modification. Furthermore, the irreversible and immutable writing process provides legal traceability and chronological verifiability to the registration process, offering a reliable foundation for digital copyright protection.

[0052] This invention achieves stability and congestion management capabilities in the similarity assessment between artworks through dynamic similarity threshold adjustment and fine-grained off-chain comparison. During the disclosure window phase, the smart contract monitors the similarity distribution between fingerprints in real time and proactively generates a congestion signal when the similarity concentration rises to the congestion threshold. This invention triggers a more refined off-chain fingerprint comparison process by instantly lowering the dynamic similarity threshold, thereby improving fingerprint discrimination capabilities while maintaining system processing efficiency. This dynamic adjustment mechanism can adapt to real-world scenarios such as a sudden increase in the number of disclosure nodes and a high density of similar artworks, ensuring the system's elasticity and stability in identifying differences between artworks and effectively avoiding registration conflicts and copyright confusion. This invention achieves the objective establishment of original artwork ownership and the systematic marking of derivative works through fingerprint clustering and detail scoring ranking mechanisms. After the disclosure window ends, this invention ranks all artworks within the same fingerprint cluster according to a preset detail scoring method, clearly identifying the highest-scoring artwork as the original and the others as derivative artworks. This mechanism achieves automatic confirmation of artwork originality, avoiding the disputes and uncertainties arising from reliance on subjective human judgment. At the same time, the derivative relationships between artworks within the cluster are systematically registered and mapped, enhancing the structured expression of copyright information and making subsequent copyright tracking, derivative management, and liability determination clearer and more traceable. Attached Figure Description

[0053] To facilitate understanding by those skilled in the art, the present invention will be further described below with reference to the accompanying drawings; Figure 1 This is a schematic diagram of the blockchain-based digital copyright registration method for artworks in this invention. Detailed Implementation

[0054] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0055] Reference Figure 1 The following examples were obtained:

[0056] Example 1: A blockchain-based method for digital copyright registration of artworks, comprising the following steps:

[0057] The registration node calculates a blinded fingerprint for the artwork to be registered, combines the blinded fingerprint with a random salt value to generate a placeholder hash, and writes it along with a trusted timestamp to the blockchain, completing the registration placeholder. The blinded fingerprint calculation by the registration node is to extract a unique compressed feature expression from the original artwork image. This feature retains the overall content structure perception ability of the image even under irreversible conditions and prevents unauthorized entities from reproducing the original image. By combining the blinded fingerprint with a random salt value generated by a high-intensity entropy source to form a unique placeholder hash, primary key conflicts caused by duplicate registration of the same work on different nodes can be effectively prevented. Simultaneously, the addition of a trusted timestamp gives the registration process temporal credibility, ensuring that the "first-come, first-served" ordering principle is acceptable to on-chain verifiers. Finally, writing this combined data packet to the blockchain makes the registration intention immutable and traceable, establishing an initial on-chain binding basis for subsequent disclosure and original ownership confirmation operations.

[0058] The smart contract determines the delay time based on a verifiable random function. Upon the delay's expiration, a disclosure window opens. Registered nodes submit their complete fingerprints (corresponding to placeholder hashes), random salt values, and artwork metadata within this window. The delay time is determined by the smart contract using a publicly verifiable random function, effectively preventing registered nodes from knowing the exact time and thus preemptively claiming disclosure order, achieving a probabilistically fair ranking. After the delay expires, the smart contract automatically opens the disclosure window, ensuring that registered nodes can only submit their actual artwork fingerprints, salt values ​​for verification, and accompanying artwork metadata within that timeframe. This avoids malicious ranking manipulation caused by artificially binding submission and on-chain times. The introduction of the disclosure window provides the system with a "submission-first-claim—unified disclosure" anti-insertion mechanism, effectively improving the fairness of original works and automatically generated images in terms of time-based ranking.

[0059] During the disclosure window, the smart contract calculates the similarity distribution among disclosed fingerprints in real time. When the number of similar fingerprints exceeds a preset threshold, a congestion signal is generated. During the disclosure window, the system automatically performs multi-scale fingerprint comparison on submitted fingerprints via the smart contract to calculate the global similarity distribution. This process is real-time, ensuring that the on-chain system is always aware of the image similarity density level within the current window. By setting a similarity threshold as a dynamic trigger point, when the system detects a large number of similar or duplicate images submitted in a concentrated manner, a congestion signal is triggered, indicating that there may be unnatural, batch submission behavior within that time period. The generation of the congestion signal serves as an early warning mechanism, driving the system to enter a more stringent fingerprint processing path to ensure that a massive number of similar images do not preempt the rights confirmation entry point in a short period.

[0060] Upon generating a congestion signal, the smart contract immediately lowers the dynamic similarity threshold and invokes an off-chain multi-scale deep feature comparison algorithm to obtain a fine-grained similarity evaluation result between fingerprints. When the congestion signal is activated, the system automatically tightens the current perceptual threshold used to judge image similarity, adjusting it to a lower lower limit, thereby narrowing the acceptable range for classifying images as "different works." This adjustment requires subsequent comparison algorithms to have higher detail resolution capabilities when processing image pairs. Simultaneously, the smart contract submits the fingerprint list to an off-chain deep comparison service, invoking a multi-scale feature extraction algorithm with a convolutional neural structure to perform fine-grained similarity scoring on the images across multiple dimensions such as texture, boundaries, and morphology. This operation generates a more credible and refined evaluation result, serving as a key technological foundation for clustering and originality confirmation.

[0061] Based on the refined similarity evaluation results, the smart contract groups fingerprints with a similarity score at or above the dynamic similarity threshold into the same fingerprint cluster and generates a unique cluster identifier for each cluster. Using the refined similarity matrix returned off-chain, it constructs a similarity graph between fingerprints on-chain and identifies all image pairs with similarity scores exceeding the current dynamic threshold, clustering them according to the graph structure. Each cluster is considered a group of potentially related artworks, with members exhibiting high similarity or derivation. To achieve continuous tracking of on-chain states, the smart contract automatically generates a unique cluster identifier for each cluster, containing a block number and a random factor, and establishes a bidirectional mapping between this identifier and cluster members. This step not only achieves the merging and isolation of similar works but also provides a structural foundation for original rights confirmation and subsequent derivative chain labeling.

[0062] When the disclosure window closes, the smart contract sorts the artworks within each fingerprint cluster based on multi-scale detail scores. The artwork with the highest detail score is registered as the original artwork, while other artworks within the same cluster are registered as derivative artworks and associated with them. After the disclosure window closes, the smart contract iterates through all generated fingerprint clusters and performs multi-scale detail score calculations on the artwork images within each cluster. This score combines multi-dimensional features such as image edges, textures, and local contrast to comprehensively evaluate the visual complexity and structural richness of the image. The system uses the score results for sorting, confirming the artwork with the highest score as the original artwork within the cluster and recording its original identity in the status table. Simultaneously, the remaining members are marked as derivative artworks, with derivative levels set according to their similarity to the original image and submission time. A traceable original-derived correspondence is established on the blockchain to ensure the structured transparency of the copyright chain.

[0063] The calculation of blinded fingerprints includes the following steps: The registration node preprocesses the digital image of the artwork to be registered according to a fixed resolution and a unified color space, and performs high-frequency noise suppression on the pixel matrix to eliminate the interference of scanning device noise on fingerprint stability. A digital image refers to an electronic file recording the artwork's graphic in a pixel array format; the format can be a compressed image or an original image. The registration node first adjusts the image to a uniform square resolution of 1024 pixels wide and 1024 pixels high, and converts it to a unified color space. This color space uses a decoupled structure for the luminance and contrast components, and the conversion result retains the luminance channel for subsequent processing. A two-dimensional pixel matrix is ​​constructed based on the luminance channel, where each element represents the grayscale value at that image location, ranging from zero to 255. The registration node performs high-frequency noise suppression based on this pixel matrix, using a 3x3 median filter operator with a sliding window to process the image area, removing edge spikes and random noise introduced during scanning or photography. The filtered image retains the original edge contours structurally, but high-frequency artifacts are effectively suppressed, improving the stability of subsequent feature extraction.

[0064] The registration node constructs a multi-scale discrete cosine transform (DAC) feature vector based on the preprocessed pixel matrix and inputs this feature vector into a one-way key hash function based on the artwork's private key to generate a privacy-preserving feature string. Multi-scale DAC refers to performing frequency domain transformation on image pixel blocks at different sizes to extract structural and texture features. The registration node divides the image into two scales: 8x8 pixel blocks and 16x16 pixel blocks. After performing a two-dimensional DAC on each block, the transform coefficients are extracted, and nine coefficients with the highest energy from the top-left low-frequency position are selected and expanded column-wise to form a set of local structural feature vectors. A total of 128 sets of feature vectors are extracted for each image, each with a dimension of nine, and are finally concatenated into a multi-scale image structural vector with a total length of 1152. To prevent direct fingerprint reversibility inference of the original image, this vector is input into a one-way key hash function. The input to the one-way key hash function is the concatenation result of the multi-scale image structural vector and the artwork's private key, and the output is a fixed-structure digest of 512 bits. The private key for an artwork is generated locally by the image registrant and is not disclosed along with the image itself. It has identity binding and privacy protection functions, ensuring that the digest can only be generated in the forward direction and cannot be reversed.

[0065] The registration node applies a reversible quantization perturbation algorithm to the privacy-preserving feature string. This reduces the probability of reconstructing individual pixels while maintaining global perceptual consistency, resulting in a blind fingerprint that is both publicly verifiable and difficult to reverse-engineer. The reversible quantization perturbation algorithm adds a perturbation term to the feature string while preserving the core perceptual features, preventing local pixels from being guessed. The algorithm divides the 512-bit feature string into 64 groups of eight bits each. For each group of eight bits, the difference between the maximum and minimum jump values ​​is calculated. If this difference is greater than 16, no perturbation is performed; if the difference is less than 16, a perturbation factor generated by a pseudo-random function (ranging from zero to seven) is added to the original value. The perturbed value is then modulo-operated within the range of eight integers to ensure no overflow. Finally, the 64 perturbed values ​​are reassembled to generate an irreversibly recoverable blind fingerprint vector. The data distribution pattern in the blinded fingerprint vector is consistent with the main structure of the original image features, but the local pixel positions are not reproducible. Even if they are obtained, the original image structure cannot be accurately reconstructed, thus ensuring dual security of privacy and copyright.

[0066] The blinded fingerprint obtained through the above three steps possesses both uniqueness and collision resistance, providing a secure fingerprint foundation for subsequent placeholder operations. The uniqueness of the blinded fingerprint is reflected in the fact that even two extremely similar images will undergo a global-level change in their final perturbation features if their pixel content or structure differs slightly. Collision resistance is reflected in the fact that the probability of a hash collision between the blinded fingerprints of any two different artwork images is less than one in a billion. This blinded fingerprint can be used as an identity credential for registering artworks on the blockchain, serving as the sole entry point for generating placeholder hashes, ownership confirmation timestamps, and copyright mappings. Due to its irreversible, secure binding, and cross-system uniqueness characteristics, it becomes the underlying fingerprint structure supporting the trusted operation of the entire blockchain-based digital copyright registration mechanism for artworks.

[0067] The generation and writing of placeholder hashes includes the following steps: The registration node randomly generates a cryptographically graded random salt value matching the length of the blinded fingerprint, and concatenates the blinded fingerprint and the random salt value in a preset order to form the original string to be hashed. The cryptographically graded random salt value is a segment of random data generated under cryptographic security requirements to prevent the same fingerprint from producing the same result multiple times on the chain, ensuring the unpredictability of the hash output. The registration node generates a random number sequence with the exact same length as the blinded fingerprint by calling the operating system's built-in security entropy source, such as an entropy pool based on environmental noise, a thermal jitter source, or a high-resolution timing difference perturbation mechanism. Taking a blinded fingerprint length of 512 bits as an example, the registration node will generate a set of 64 groups of 8-bit integers, each group ranging from zero to 255.

[0068] When concatenating a blinded fingerprint with a random salt value, the fingerprint is appended first, followed by the salt value. The concatenation method is to add the first eight digits of the blinded fingerprint first, then the first eight digits of the corresponding salt value, and so on, forming a 1024-bit original string to be hashed. This structure avoids prefix collisions, ensuring that even if two images have the same fingerprint, the resulting strings will be different after adding different salt values.

[0069] The registration node uses the Secure Hash Algorithm Version 3 (SHA) to calculate a fixed-length hash on the original string to be hashed, obtaining a placeholder hash, and simultaneously requests a trusted timestamp signature from a distributed timestamp authority. SHA is a one-way irreversible function defined by national cryptographic standards, characterized by compression, collision resistance, and strong scalability. In this method, the registration node calls the SHA function with a fixed length of 512 bits to perform a one-way hash on the previously concatenated 1024-bit original string, outputting a fixed placeholder hash value of 256 bits. This hash value serves as a unique identifier for subsequent on-chain registration activities, possessing anti-tampering and deduplication detection capabilities.

[0070] After hashing is complete, the registering node uses the placeholder hash as part of the original data and simultaneously submits a timestamp request to the distributed timestamp authority that has joined the blockchain network. This authority, through a consensus signature mechanism, affixes a trusted timestamp to the received hash value, which includes fields such as the receiving time, node signature, and network-wide chain number index, forming a complete trusted timestamp signature structure. This signature structure possesses timeliness, consistency, and repeatability, ensuring that the entire registration process has legal validity and third-party independence in terms of time.

[0071] The registration node writes a placeholder hash, a random salt value, and a trusted timestamp as an indivisible data packet into the blockchain transaction payload and broadcasts it to the network. The placeholder record is immutable from the moment the first confirmed block is generated. After obtaining the trusted timestamp signature, the registration node combines these three types of data into a complete data packet. This data packet structure contains three parts: first, a placeholder hash value, occupying 256 bits, used as a unique registration identifier; second, a cryptographically graded random salt value, occupying 512 bits, used as the basis for verification in subsequent disclosures; and third, a trusted timestamp signature structure, occupying a variable-length field, typically containing signature information, a time field, and an on-chain number, totaling approximately 1000 bits. This entire data packet is encoded as part of the data payload in the blockchain transaction structure and submitted to the entire network via broadcast, entering the transaction pool of the accounting nodes. When miners or validators package a new block, they include this transaction in the new block and record its hash digest in the block header. With the on-chain confirmation of the new block, the entire data packet content becomes an indivisible part of that block, which can be read retrospectively by any node in the future and cannot be tampered with or revoked.

[0072] The placeholder operation implemented through the above three steps ensures that any subsequent registration request must reference the same blinded fingerprint and random salt value combination, avoiding disputes over originality caused by massive insertion by generators. Since the generation of placeholder hashes strictly depends on the unique combination of the blinded fingerprint and random salt value, any change to the fingerprint or use of different salt values ​​will lead to unpredictable changes in the hash value. Therefore, during the disclosure window, if a registration node cannot submit a complete fingerprint and salt value pair that perfectly corresponds to the hash, subsequent rights confirmation cannot be completed, and the system will automatically deem the registration invalid. Simultaneously, because the entire registration record has an on-chain timestamp, any image generator attempting to mass-place places before the actual artwork is revealed must know the artist's image details and salt value structure in advance, which is virtually impossible in practice. This effectively prevents malicious insertion attacks that could seize originality rights, ensuring the priority of the true author in terms of time and structure for rights confirmation.

[0073] The process of determining the delay time based on a verifiable random function includes the following steps: After receiving the placeholder hash, the smart contract calls the block header random number, the node key commitment value, and the current network difficulty to form the input seed, providing multi-source entropy for the verifiable random function; the block header random number refers to the unpredictable random value contained in the most recently consensus-completed block on the current main chain, and its generation method usually relies on the threshold aggregation signature results submitted by validators under the proof-of-stake mechanism. For example, in a proof-of-stake network, the system uses a mixed entropy value calculated and aggregated by all validators. This entropy value is usually 256 bits long and can be obtained by calling the on-chain randomness interface through the smart contract.

[0074] The node key commitment value refers to a key digest that a block node publishes in advance during the previous consensus cycle for future behavior verification. This digest is obtained by securely hashing the node's one-time public key and is 256 bits long, used to prevent subsequent forgery of the input entropy. The current network difficulty refers to the block challenge strength index that the main chain automatically adjusts over a specific period. It can be calculated based on the average interval time of the previous 100 blocks, and in the proof-of-stake mechanism, it can also be expressed as the weighted inverse of the average slot spacing. This value is usually a positive integer, generally ranging from billions to tens of billions. These three values ​​are combined into an input seed of 768 bits, serving as the input to a verifiable random function. This provides a sufficient and unpredictable multi-source entropy input for subsequent random delay generation, ensuring that no single node can control the delay time.

[0075] The smart contract feeds an input seed into a verifiable random function based on the elliptic curve digital signature algorithm. The output is a pseudo-random number that is unpredictable for any single node and publicly verifiable, while simultaneously generating a zero-knowledge proof. The verifiable random function is a tamper-resistant pseudo-random number generation mechanism whose output is both unpredictable and publicly verifiable to external verifiers. Upon receiving the input seed, the smart contract invokes the random function component built on the elliptic curve digital signature algorithm. Specifically, the curve used can be a family of parameters with a security level of 256 bits from the elliptic curve hyperbola set, and a digital signature operation is performed based on this curve.

[0076] The input seed serves as the private key's computation factor, generating a 256-bit random output through elliptic curve mapping. This output value falls between zero and 2^256 minus one. To prevent nodes from forging results, the random function simultaneously generates a zero-knowledge proof. This proof employs a non-interactive proof structure, constructing a cryptographic commitment and challenge-response pair to prove that the pseudo-random number was indeed uniquely calculated from the input seed and that the calculation process was not tampered with. This pseudo-random number serves as the basis for the final delay calculation, satisfying the requirements of unpredictability, repeatability, and determinism. Furthermore, by being jointly written into the blockchain state with the zero-knowledge proof, it allows any node to verify the legitimacy of the delay source without requiring trust.

[0077] The smart contract uses a pseudo-random number to linearly map the delay time within a preset shortest and longest delay range, and writes the delay time and zero-knowledge proof into the blockchain for external node verification. The disclosure window automatically opens after the delay expires. The system sets a uniform upper and lower limit for the delay time range; for example, the shortest delay is 50 block heights, and the longest delay is 150 block heights, meaning the disclosure window will open between 50 and 150 blocks after the placeholder registration. The smart contract normalizes the pseudo-random number to a small value between zero and one using the following formula: divide the pseudo-random number by the maximum possible value (2 to the power of 256 minus 1), multiply by the interval length of 100, add the lower limit of 50, and round the result to the final integer number of delayed blocks.

[0078] For example, if the pseudo-random number, after normalization, results in 0.45, the final delay time will be 50 plus 45, or 95 blocks. With a block interval of 12 seconds set by the blockchain platform, this delay time is approximately 19 minutes. The delay time and its corresponding zero-knowledge proof are synchronously written to the transaction log and contract state table for subsequent network participants to verify its compliance. When the on-chain height reaches the placeholder transaction confirmation height plus the number of delayed blocks, the smart contract automatically opens the disclosure window for the corresponding work, allowing registration nodes to submit the corresponding complete fingerprint, salt value, and metadata, entering the next stage of the rights confirmation process. This delay control mechanism enables "first-come, first-served" registration intent, effectively suppressing attack paths where automatically generated images seize the initiative in a very short time, while ensuring both the fairness of the disclosure window and on-chain verifiability.

[0079] The seed generation process includes the following steps: After writing the placeholder hash, the smart contract immediately reads the random number segment from the header of the most recently consensus-reached block and broadcasts this random number through the event log, allowing any node to trace and verify it. The random number segment in the block header refers to the random entropy value field in each newly generated block on the chain. This value is generated by different methods under different consensus mechanisms. In the Proof-of-Stake consensus mechanism, this field usually originates from the random number aggregation result of the previous verification cycle. Specifically, it is a network-wide mixed random value generated by weighted aggregation after all active validators perform threshold signatures on the specified seed according to the key signature order, and the validator nodes perform the aggregation. This field can be directly accessed through the random value field in the on-chain block structure. In the Proof-of-Work network, this field can be replaced by a field with a fixed offset selected from the work output hash result of the previous block.

[0080] Within the same transaction processing cycle after the placeholder hash is successfully written, the smart contract calls the on-chain interface function to read the latest consensus-reached block header random value. This value, along with the identity information of the current transaction initiating node, is encapsulated as an on-chain event and broadcast to all full nodes via the event log. This ensures that all network participants can retrospectively verify that the random value originates from on-chain history and has not been manipulated. This field, as part of the input seed, provides the random function with uncertainty entropy input under global consensus, ensuring its unpredictability and non-replayability.

[0081] Before the next block production cycle, the block-producing validator calculates a secure hash of its one-time public key to obtain a node key commitment value, and submits it along with its digital signature to the on-chain key commitment registration contract. The smart contract verifies and immediately publishes this commitment value. The one-time public key is an encrypted public key temporarily generated by the block-producing validator before each block production cycle to prevent future information tampering or replay, used for pairing and verification during subsequent identity verification. After generating the one-time key pair, the block-producing validator hashes the public key using a secure hash algorithm from the national cryptographic standard, resulting in a 256-bit node key commitment value.

[0082] To ensure the validity and correspondence of the commitment value, the verifier must also sign the hash result using the current identity key, and encapsulate the commitment value and the signature result together into a submission data packet, which is then written to the key commitment registration contract running on the chain. Upon receiving this data, the contract will match and verify the signature against the identity pair. If the signature is genuine, the structure is correct, and the submission period is legal, the contract will immediately write the node's key commitment value as a public state into the mapping table and bind it to its block production period. This key commitment value participates in seed construction when generating pseudo-random numbers, ensuring that the pseudo-random numbers not only originate from on-chain data but also contain the node's independently contributed cryptographic commitment, increasing the unpredictability and anti-forgery capability of the random source.

[0083] The smart contract continuously retrieves the difficulty field of several latest blocks within a preset window, calculates the sliding average to form the current network difficulty, and synchronously writes it to the state storage along with a timestamp. The current network difficulty is a key parameter for measuring the computational complexity of the block generation process, reflecting the real-time pressure of block generation and network activity. The smart contract sets the sliding window length to one hundred blocks. After receiving a new placeholder request, it automatically retrieves the difficulty field from the headers of the most recent one hundred blocks backward from the current chain height, extracts each field, and assembles a difficulty sequence of length one hundred. For this sequence, the contract calculates its arithmetic mean to obtain the average block difficulty within the current time period, used to eliminate the interference of single abnormal fluctuations on random generation. If the blockchain system being run is a proof-of-stake network, the average slot interval or block generation interval of each block is extracted as a logically equivalent difficulty indicator and equivalently converted. This average is written as the current network difficulty into the smart contract state variable, with the current system timestamp attached at the time of writing, ensuring that the input seeds generated subsequently are highly consistent with the actual block generation status of the network in time, and are not affected by short-term anomalies such as isolated blocks or delayed blocks. The network difficulty participates in the construction of the pseudo-random function input seed, and together with the block header random number and the node key commitment value, it forms a complete three-source entropy structure, providing a high-quality, unpredictable input foundation.

[0084] The process of generating congestion signals includes the following steps: The smart contract performs a discrete cosine transform on each fingerprint pair within the same block after four levels of scaling, extracts the bit string, calculates the Hamming distance, and generates a multi-scale perceptual distance list; each fingerprint pair refers to an artwork fingerprint pair that has successfully completed its reveal and entered the similarity detection process in the current block. The smart contract performs four levels of image scaling on each fingerprint image, specifically including original resolution, 1 / 2, 1 / 4, and 1 / 8 scaling. Each scaling level uses a conservative mean downsampling method, dividing the image into blocks and using the mean of each block's pixels as the corresponding pixels in the target image to preserve image contour features and reduce noise impact.

[0085] For each scaling level of the image, the smart contract performs a two-dimensional discrete cosine transform, converting the image patch into a frequency domain coefficient matrix. Within each frequency domain matrix, the smart contract selects eight low-frequency coefficients from the top-left region and combines them into a bit string of length eight, arranged from left to right and top to bottom. The four scaling levels will generate four sets of bit strings, totaling thirty-two bits of information, used to represent the structure-aware features of the image at multiple scales.

[0086] The smart contract compares each pair of bit strings between all image fingerprints within the current block, calculating their Hamming distance, which is the total number of different corresponding bit positions. The Hamming distances of all fingerprint pairs are recorded in a multi-scale perceptual distance list, where each entry contains a fingerprint pair, a distance value scaled at four levels, the average distance, and an aggregate score. This data structure is used for subsequent similarity determination.

[0087] Using the most recent few reveal records as a window, fingerprints with a distance below the current similarity threshold are marked as similar, and the similarity count within the window is counted. The smart contract maintains a sliding window to count the number of similar fingerprints generated in the most recent few reveal actions. Using the most recent n reveal records as a window, for example, the window size is one hundred, means that whenever a new fingerprint reveal is completed, the oldest data will be removed and the latest record will be added, ensuring that the counted data reflects the similarity density state of the revealed images at the current stage.

[0088] For all fingerprint pairs within the current sliding window, the smart contract determines whether their average multi-scale perceptual distance and aggregate score are below the similarity threshold for the current system operation. If the distance value is less than the threshold, the fingerprint pair is considered a similar pair, and the record is added to the similarity count. This similarity count represents the aggregated similarity of image content within the current window and is a key indicator for the system to monitor for insertion attacks or large-scale duplicate image generation.

[0089] The system calculates the average similarity count over the previous m windows. Multiplying this average by the reciprocal of the product of preset safety factors yields the dynamically tightened new threshold. To determine if the similarity count in the current window is abnormal, the smart contract establishes a historical baseline. The system sets the sliding window's historical depth to ten, meaning the smart contract records the similarity counts from the past ten windows, forming a historical count sequence. The arithmetic mean of this sequence is calculated and recorded as the historical mean. Furthermore, the system maintains a set of safety factors related to window state, network congestion probability, and block interval changes, such as window congestion factor, node feedback factor, and historical disclosure delay factor. Each safety factor is a decimal greater than zero, and the product of all factors is recorded as the safety factor product. The system uses the reciprocal of this safety factor product as a risk adjustment factor; multiplying the historical mean by this reciprocal yields the dynamically tightened new threshold. For example, if the average similarity count of the first ten windows is 150 pairs, and the safety factors are 0.8, 0.9, and 0.95 respectively, then their product is 0.684, and the reciprocal is approximately 1.462. The new threshold is 150 multiplied by 1.462, which is approximately 219. This threshold represents the maximum number of similar pairs that the system can tolerate for the current window. Once the actual similarity count exceeds this value, congestion occurs. m and n are both preset positive integers.

[0090] A congestion signal is triggered when the similarity count in the current window exceeds a new threshold. The smart contract continuously monitors the real-time similarity count within a sliding window. When this value first exceeds the dynamically calculated threshold, the system immediately triggers a congestion signal. The congestion signal is triggered via an event broadcast mechanism within the smart contract, and the time of congestion and the corresponding block number are marked in the on-chain state table. This signal synchronously activates multiple subsequent on-chain and off-chain processing flows, including tightening the similarity judgment precision, calling the off-chain deep feature comparison module, adjusting the perceptual hash distance calculation precision, increasing fingerprint clustering density, and freezing permissions for addresses with abnormally frequent submissions. By introducing the congestion signal mechanism, the system can adopt more stringent and refined processing strategies in high-risk areas where image reveal behavior is concentrated and content similarity increases sharply, preventing the large-scale automated forging behavior of generators from impacting the originality ranking structure.

[0091] The process of immediately reducing the dynamic similarity threshold and obtaining fine-grained similarity evaluation results between fingerprints after generating a congestion signal includes the following steps: After the congestion signal is triggered, the smart contract multiplies the preset similarity threshold by a preset contraction coefficient to generate a contraction threshold and immediately updates the global state. The similarity threshold refers to the system reference value currently used to determine whether two sets of fingerprints are similar. Under normal conditions, this value is adjusted based on the historical window mean and safety factor, and its unit is Hamming distance or distance normalization ratio. The preset contraction coefficient is a fixed compression ratio configured in the on-chain parameters, used to quickly tighten the system's tolerance for similarity after the network or window enters an abnormal state. This coefficient typically ranges from 0.6 to 0.9; for example, a contraction coefficient of 0.75 means that only 70% of the original judgment distance is allowed after contraction.

[0092] Immediately after the system triggers a congestion signal, the smart contract multiplies the currently preset similarity threshold by a shrinkage coefficient to obtain the shrinkage threshold. For example, if the current threshold is a 32-bit Hamming distance and the shrinkage coefficient is 0.75, then the shrinkage threshold is a 24-bit distance. The newly generated shrinkage threshold is immediately written to the contract status table, replacing the dynamic threshold as the sole threshold referenced for subsequent similarity judgment and comparison operations. Simultaneously, the adjustment operation is written to the event log for later verification and backtracking.

[0093] The smart contract synchronously broadcasts a list of fingerprints to be evaluated and a shrinking threshold to the off-chain feature comparison service, along with a random challenge value to ensure the verifiability of the returned results. The off-chain feature comparison service is an auxiliary computing system deployed in a trusted environment, capable of performing complex neural network operations and generating proof structures. After updating the shrinking threshold, the smart contract extracts all artwork fingerprints to be clustered in the current disclosure window, forming a list of fingerprints to be compared, typically consisting of thirty to five hundred image structure vectors. The contract packages the fingerprint list and the shrinking threshold into a data packet and broadcasts it to the off-chain comparison service via an asynchronous message mechanism as an initialization instruction for a comparison task. Simultaneously, to prevent the off-chain returned data from being forged or replayed, the contract synchronously generates a set of random challenge values ​​calculated based on the block height, node address, and task number hash. This value is embedded in the data packet, requiring the off-chain service to return a computational proof bound to it after calculation, ensuring the legitimacy, non-replicability, and one-time nature of the task response.

[0094] Upon receiving instructions, the off-chain alignment service extracts deep features using a multi-scale convolutional network, calculates the cosine distance between fingerprints, and returns a fine-grained similarity matrix with zero-knowledge proofs. The service performs multi-scale convolutional neural network processing on each fingerprint image to extract its deep structural features. The network structure typically consists of four convolutional layers, each processing edge, texture, shape, and region distribution at different spatial frequencies. The results of each convolutional layer are batch normalized and output through an activation function, ultimately concatenating into a 1024-dimensional deep feature vector to describe the overall structural semantic information of the image.

[0095] For any two deep feature vectors, the off-chain system calculates the cosine distance as a similarity score, using the formula: feature vector dot product divided by the product of their respective magnitudes. A cosine distance close to one indicates that the two images are highly similar, while a distance close to zero indicates that the two images are significantly different. The off-chain system organizes the cosine distances between all images into a symmetric matrix, denoted as the fine similarity matrix, with dimensions n x n, where n is the number of images involved in the comparison. The comparison service constructs a zero-knowledge proof based on the challenge value attached to the initialization instruction, proving that the matrix result was calculated from the given input and that the intermediate process was not modified. This proof uses a non-interactive zero-knowledge structure, including commitment terms, response terms, and cryptographic tags, and can be quickly verified on-chain using a unified verification algorithm.

[0096] After the smart contract verifies the zero-knowledge proof, it writes the fine-grained similarity matrix into the fingerprint clustering mapping table for subsequent originality confirmation. After the comparison result is returned, the smart contract first verifies the integrity of the attached zero-knowledge proof. The verification algorithm compares the challenge value and the shrinkage threshold to confirm the consistency between the comparison task and the response data. At the same time, it verifies that the response items in the proof and the submitted results mathematically satisfy the construction rules, ensuring that the calculation results are credible and have a unique source.

[0097] After verification, the contract writes the fine-grained similarity matrix into the fingerprint clustering mapping table according to the standardized structure. This mapping table is an on-chain structured state object used to record high-precision similarity scores between image fingerprints, serving as the core basis for subsequent clustering, original selection, and derivative identity binding. Each similarity score record consists of two image identifier codes, a set of floating-point score values, a comparison period stamp, and a confirmation flag. Once written, it can be read in real time by the original confirmation process and supports sorting and filtering operations. Through the above process, the system switches to a higher-precision off-chain comparison path under congestion, maintaining responsiveness to high-frequency attack scenarios while ensuring result verifiability and processing efficiency, thus building a secure, stable, and reliable foundation of data for clustering and rights confirmation.

[0098] Grouping fingerprints with similarity scores at or above the dynamic similarity threshold into the same fingerprint cluster means that after receiving the fine-grained similarity matrix, the smart contract maps fingerprint pairs with similarity scores above the dynamic similarity threshold (i.e., the shrinkage threshold) to edges in a graph structure and constructs a similarity graph in real time. The fine-grained similarity matrix is ​​a symmetric matrix used to record the similarity scores between all revealed artwork fingerprints. Each cell represents the cosine distance score between two images, with the score ranging from zero to one decimal; the larger the value, the more similar the images. After reading this matrix, the smart contract iterates through each fingerprint pair's score and marks fingerprint pairs with scores greater than the current shrinkage threshold as edges in the graph structure. Each edge indicates that two image nodes have strong similarity at the visual structural level and should belong to the same visual cluster. For example, in a comparison result containing fifty artwork images, if the similarity score between the tenth and eighteenth images is 0.92, which is higher than the current shrinkage threshold of 0.85, then an undirected edge from number ten to number eighteen is added to the similarity graph, and the edge is labeled with a score weight. The process continuously scans the matrix, gradually generating a set of similar nodes composed of fingerprint images and the edge connections between them in the graph structure.

[0099] The smart contract calls the on-chain disjoint-set data structure (DFS) algorithm to merge connected nodes from bottom to top on the similarity graph. After each merge, the fingerprint with the highest edge weight is automatically selected as the cluster root of that connected component. Once the similarity graph is constructed, the smart contract uses it as input to call the on-chain DFS structure to merge nodes. The DFS is a dynamic data structure that efficiently maintains the merging and membership relationships of sets. In the on-chain environment, it is implemented as a mapping table, where the key is the fingerprint identifier and the value is the root node identifier of the set to which the fingerprint currently belongs. Initially, all fingerprint nodes form their own cluster, and the root node is its own identifier. The contract traverses all edges in the similarity graph according to the edge table. For each edge processed, the following steps are executed:

[0100] The first step is to call the path compression search algorithm to obtain the root nodes of the nodes at both ends of the current connection;

[0101] The second step is to call the rank-based merging strategy if the two root nodes are different, and merge the set with fewer nodes into the set with more nodes.

[0102] The third step, after merging, is to set the root node of the new set as the cluster representative, i.e., the fingerprint with the highest weight, based on the maximum edge weight. The edge weight is the similarity score between the fingerprint pairs, directly taken as a floating-point number at the corresponding position in the fine similarity matrix. For example, if the edge score between node 5 and node 24 is 0.98, which is the highest score in the current graph, and 5 and 24 are eventually merged into one cluster, then node 5 is designated as the root node of this cluster. All fingerprints belonging to this cluster will point to this node as their affiliation identifier in subsequent steps.

[0103] The smart contract concatenates the root fingerprint of each cluster with the current block number and random entropy to calculate a secure hash, generating a unique cluster identifier. This cluster identifier is then bidirectionally mapped to all fingerprints within the cluster and stored in a state table. After merging the cluster structures, the smart contract traverses all current cluster structures, constructing a unique identifier using the root node of each cluster as the core identity. The generation method involves concatenating the image fingerprint number of the root node with the current block number, adding a 256-bit random string extracted from the system entropy source, and then inputting the entire data into a secure hash algorithm based on national cryptographic standards. The output is a 256-bit hash value as the unique cluster identifier. For example, using fingerprint number 37 as the root node, with a block number of 1020 and a random entropy of the binary string "010011", the concatenated input string is "37 + 1020 + 010011". After hash calculation, a cluster identifier such as "987654321" is generated. The smart contract establishes a bidirectional mapping relationship between this identifier and the fingerprints of all members in the cluster, storing it in an on-chain state mapping table. This mapping table is a list of mapping groups, each containing a cluster identifier key and a list of member fingerprint values. At the same time, each member fingerprint also points to its respective cluster identifier in its registration mapping table.

[0104] The scoring weights are determined as follows: the scoring weight of each edge represents the structural similarity strength between image fingerprints, and is calculated synchronously by the off-chain feature alignment service when generating the fine similarity matrix and then assigned to each fingerprint pair. Specifically, the off-chain alignment service extracts deep structural feature vectors from any two image fingerprints. Each feature vector is a 1024-dimensional real number array, representing the image's features in multiple dimensions such as edge direction, texture density, and spatial distribution. For any two feature vectors, the system calculates the cosine similarity using the following formula: Cosine similarity = dot product of feature vector 1 and feature vector 2 divided by the magnitude of feature vector 1 multiplied by the magnitude of feature vector 2. The dot product is the sum of the product of corresponding dimensions, and the magnitude is the square root of the sum of the squares of all elements. The result fluctuates between zero and one, where one indicates complete similarity and zero indicates complete irrelevance.

[0105] After calculation, this value is used as the scoring weight of the connection and appended to the corresponding position in the fine similarity matrix. For example, if the cosine similarity between image number 5 and image number 9 is 0.945, this value is assigned to the connection between image number 5 and image number 9, serving as the weight basis for subsequent on-chain disjoint-set data and cluster root selection. In actual implementation, to avoid the propagation of floating-point errors, the off-chain system performs fixed-point retention processing on the cosine similarity value to four decimal places and converts it into an unsigned fixed-length integer for storage. For example, multiplying 0.945 by 10,000 and rounding down yields 9,450, which is used as the integer scoring value of the connection and sent to the on-chain for weight comparison and priority merging judgment. The higher the scoring weight, the stronger the similarity between the two fingerprint images. If there are multiple mergeable paths in multiple connected components, the smart contract prioritizes merging the path with the highest scoring weight and sets the fingerprint with the highest scoring value as the cluster root node, thereby forming an intra-cluster structure with the greatest central representativeness.

[0106] The smart contract performs a three-level discrete wavelet decomposition on the complete fingerprint within each fingerprint cluster, calculates the detail energy of each level, and summarizes it into a multi-scale detail score according to preset weights. A complete fingerprint refers to the undisturbed digital artwork features submitted during the reveal phase. The system first performs an image multi-scale decomposition operation on the fingerprint image, based on a discrete wavelet decomposition model. In the first decomposition, the image is decomposed into low-frequency information and high-frequency information in three directions, corresponding to horizontal, vertical, and diagonal details in the image, respectively. The second decomposition performs the same decomposition again on the low-frequency portion to obtain the second level of detail information. The third decomposition follows the same process to construct a three-scale detail structure.

[0107] For each layer, the system extracts high-frequency image regions in three directions, sums the squared brightness values ​​of all pixels in each region, and uses this sum as the detail energy for that layer. The detail energies in the three directions are summed to obtain the total detail energy for that layer. The total detail energy for each of the three layers is then multiplied by preset weighting coefficients, with the first layer having the highest weight, the second the lowest, and the third the lowest. The weighted detail energies from the three layers are then summed to form the multi-scale detail score of the artwork, representing the texture complexity and intensity of local variations at different visual scales.

[0108] The smart contract sorts cluster members from highest to lowest according to their multi-scale detail scores. If the difference between the highest and second-highest scores is less than a threshold, a visual entropy comparison is added to determine a unique first-place ranking. After sorting, the system first determines whether the difference between the highest-scoring artwork and the second-highest-scoring artwork is significant. If the difference is less than a set threshold, meaning the score difference is insufficient to form a significant distinction, the system activates a backup comparison mechanism and performs visual entropy analysis. Visual entropy represents the information density and complexity of image content in visual space. It is calculated by statistically analyzing the frequency of each grayscale value in the image, then multiplying all grayscale frequencies by their logarithms, and taking the negative value as the image's entropy. The higher the entropy value, the more complex the image content, indicating that the artwork contains richer detailed structures and randomness, and has a stronger possibility of originality.

[0109] If the visual entropy results show that the image complexity of a particular artwork is significantly higher than that of other candidates, then that artwork is ultimately selected as the primary original. This strategy prevents the determination of originality from becoming ambiguous due to overly similar detail scores.

[0110] The smart contract registers the top-ranked artwork as the original artwork and writes its derivative relationship into the state mapping table for the remaining artworks in the same cluster, recording the original identifier, derivative level, and timestamp. After determining their ranking, the artwork's digital identity is written into the original register, including its cluster number, upload node, reveal time, image fingerprint hash value, and current block height. The remaining artworks in the cluster ranked lower than the original artwork are written into the derivative record table, establishing a bidirectional mapping relationship between each work and the original. Each derivative record includes the original work's identity number, the current derivative work's level number, the relative position of that derivative level within the cluster, and the timestamp of registration completion. This structure ensures that every artwork can be traced back to its source, forming a verifiable chain of originality and derivatives within the system. The design goal of this mechanism is to ensure that in legal scenarios such as copyright confirmation, originality disputes, and liability determination, the system can provide a clear, stable, and tamper-proof mechanism for identifying the original source and a channel for tracing derivatives. It also possesses sufficient detail-oriented identification capabilities to combat complex attacks such as image manipulation, splicing forgery, and duplicate registration, safeguarding a fair and impartial basis for authenticating digital rights to artworks.

[0111] To further optimize implementation, the following information is added:

[0112] To enhance the robustness and comparability of visual entropy under different image resolutions, cropping ratios, or corner occlusion conditions, the system introduces a partitioning and redundant entropy removal mechanism before calculating the overall grayscale entropy. Specifically, the system divides the digital image into several fixed-size grid cells, and each cell's local entropy value is calculated based on its grayscale histogram. To avoid large blank areas diluting the global entropy value, the system automatically removes low-variance grid cells during the calculation process. The removal criterion is that the standard deviation of pixel grayscale within a cell is lower than a preset minimum variation threshold. The final visual entropy index of the image is defined as the weighted average of the local entropy values ​​of all valid cells, with the weights set according to the proportion of non-zero pixels in each cell. This mechanism effectively improves the stability of entropy evaluation under scanning artifacts, corner trimming, and compression reconstruction scenarios, ensuring consistency and robustness in originality determination across multiple versions of artworks.

[0113] When a registered original artwork is deregistered by the system due to voluntary withdrawal, revocation of ownership, or failure to confirm ownership, the smart contract automatically triggers the inheritance ranking process for that cluster. The system re-performs detail energy calculation and visual entropy evaluation for all members in the cluster and generates a new ranking list based on the original multi-scale detail scoring model. If the difference between the score of the first artwork in the new ranking and the second highest score is greater than the set original ownership confirmation threshold, the system confirms it as a new original work in the cluster; the remaining members inherit the original derivative level and automatically update their derivative path pointers. If the score difference is insufficient to form a clear original determination, the system marks the cluster as temporarily unconfirmable, pending a re-evaluation process triggered by subsequent new works. This inheritance ranking mechanism ensures the legitimate inheritance of the originality relationship of the cluster during the long-term evolution process, effectively avoiding ownership gaps or liability drift caused by the invalidation of original works.

[0114] When artwork registration information needs to be updated due to restoration, fine-tuning, or stylistic evolution, the system provides a fingerprint evolution version management mechanism. Registration nodes recalculate the blinded fingerprint for the revised artwork image and assess stability based on the deep feature cosine similarity between the current fingerprint and the original fingerprint. If the similarity exceeds the version tolerance threshold, the system considers the fingerprint to be a continuous version of the original work. A smart contract automatically generates a unique version identifier, calculated using the original fingerprint hash, the current timestamp, and the revision number, ensuring unidirectional irreversibility and verifiability. The system constructs a version evolution chain in the state table, supporting queries for the original root node, evolution path, and registration history of each version. This ensures that artworks maintain registration continuity and ownership integrity during content adjustments, while effectively preventing duplicate registrations and ownership drift.

[0115] The above algorithms or formulas are all dimensionless and numerical calculations, and the results are obtained by software simulation based on a large amount of collected data to obtain the most recent real-world results. The preset parameters are set by those skilled in the art according to the actual situation.

[0116] It should be understood that in the various embodiments of this application, the order of the above-mentioned processes does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this application.

[0117] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0118] Those skilled in the art will readily understand that, for the sake of convenience and brevity, the specific working processes of the devices and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here. The above descriptions are merely specific embodiments of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A blockchain-based method for registering digital copyrights of artworks, characterized in that: Includes the following steps: The registration node calculates a blinded fingerprint for the artwork to be registered, combines the blinded fingerprint with a random salt value to generate a placeholder hash, and writes it along with a trusted timestamp into the blockchain to complete the registration placeholder. The smart contract determines the delay time based on a verifiable random function. When the delay expires, a disclosure window is opened. The registered node submits the complete fingerprint, random salt value and artwork metadata corresponding to the placeholder hash in the disclosure window. During the reveal window, the smart contract statistically analyzes the similarity distribution among revealed fingerprints in real time, and generates a congestion signal when the number of similar fingerprints exceeds a preset threshold. After generating the congestion signal, the smart contract immediately lowers the dynamic similarity threshold and calls the off-chain multi-scale deep feature comparison algorithm to obtain the fine similarity evaluation results between fingerprints. Based on the results of the fine similarity evaluation, the smart contract groups fingerprints with a similarity of not less than the dynamic similarity threshold into the same fingerprint cluster and generates a unique cluster identifier for each fingerprint cluster. When the disclosure window ends, the smart contract sorts the artworks in each fingerprint cluster according to the multi-scale detail score, registers the artwork with the highest detail score as the original artwork, and registers other artworks in the same cluster as derivative artworks and establishes a relationship between them. The calculation of blinded fingerprints includes the following steps: The registration node preprocesses the digital image of the artwork to be registered according to a fixed resolution and a unified color space, and performs high-frequency noise suppression on the pixel matrix to eliminate the interference of scanning device noise on fingerprint stability; The registration node constructs a multi-scale discrete cosine transform feature vector based on the preprocessed pixel matrix, and inputs the feature vector into a one-way key hash function based on the artwork's private key to generate a privacy-preserving feature string; The registration node applies a reversible quantization perturbation algorithm to the privacy-preserving feature string to reduce the probability of single-point pixel reconstruction while maintaining global perception consistency, thus obtaining a blind fingerprint.

2. The blockchain-based digital copyright registration method for artworks according to claim 1, characterized in that, The generation and writing of placeholder hashes includes the following steps: The registration node randomly generates an encrypted random salt value that matches the length of the blinded fingerprint, and concatenates the blinded fingerprint and the random salt value in a preset order to form the original string to be hashed; The registration node uses the Secure Hash Algorithm Version 3 to calculate a fixed-length hash of the original string to be hashed, obtains a placeholder hash, and synchronously requests a trusted timestamp signature from the distributed timestamp authority. The registering node writes the placeholder hash, random salt value and its trusted timestamp as an indivisible data packet into the blockchain transaction payload and broadcasts it to the network. The placeholder record is immutable when the first confirmed block is generated.

3. The blockchain-based digital copyright registration method for artworks according to claim 1, characterized in that, The process of determining the delay time based on a verifiable random function includes the following steps: After receiving the placeholder hash, the smart contract calls the block header random number, the node key commitment value and the current network difficulty to form the input seed, which provides multi-source entropy for the verifiable random function. The smart contract puts the input seed into a verifiable random function based on the elliptic curve digital signature algorithm, outputs a pseudo-random number that is unpredictable for any single node and can be publicly verified, and generates zero-knowledge proofs simultaneously. The smart contract obtains the delay time by linearly mapping pseudo-random numbers within a preset shortest and longest delay interval, and writes the delay time and zero-knowledge proof into the blockchain for external nodes to verify. The disclosure window is automatically opened after the delay expires.

4. The blockchain-based digital copyright registration method for artworks according to claim 3, characterized in that, The process of generating the input seed includes the following steps: The smart contract immediately reads the random number segment of the header of the most recently consensus-reached block after the placeholder hash is written, and broadcasts the random number through the event log. Before entering the next block production cycle, the block validator calculates a secure hash using a one-time public key to obtain the node key commitment value, and submits it along with its digital signature to the on-chain key commitment registration contract. The smart contract verifies the commitment value and immediately publishes it. The smart contract continuously retrieves the difficulty field of several latest blocks within a preset window, calculates the moving average to form the current network difficulty, and writes it to the state storage along with the timestamp.

5. The blockchain-based digital copyright registration method for artworks according to claim 4, characterized in that, The process of generating a congestion signal includes the following steps: The smart contract performs a discrete cosine transform on each pair of fingerprints within the same block after four levels of scaling, extracts the bit strings and calculates the Hamming distance, and generates a multi-scale sensing distance list. Using the most recent n revealed records as a window, fingerprints with a distance lower than the current similarity threshold are marked as similar, and the similarity count within the window is counted. Calculate the average similarity count of the first m windows, and use the reciprocal of the product of this average and the preset safety factor as the new threshold after dynamic tightening; A congestion signal is triggered when the similarity count in the current window exceeds a new threshold.

6. The blockchain-based digital copyright registration method for artworks according to claim 5, characterized in that, The process of immediately reducing the dynamic similarity threshold and obtaining fine-grained similarity evaluation results between fingerprints after generating a congestion signal includes the following steps: After a congestion signal is triggered, the smart contract multiplies a preset similarity threshold by a preset contraction coefficient to generate a contraction threshold and immediately updates the global state. The smart contract simultaneously broadcasts the list of fingerprints to be evaluated and the narrowing threshold to the off-chain feature comparison service, along with a random challenge value; After receiving the instruction, the off-chain comparison service extracts deep features using a multi-scale convolutional network, calculates the cosine distance between fingerprints, and returns a fine similarity matrix with zero-knowledge proofs. After the smart contract verifies that the zero-knowledge proof is correct, the fine similarity matrix is ​​written into the fingerprint cluster mapping table for subsequent originality confirmation.

7. The blockchain-based digital copyright registration method for artworks according to claim 6, characterized in that, Grouping fingerprints with similarity at or above the dynamic similarity threshold into the same fingerprint cluster refers to: After receiving the fine similarity matrix, the smart contract maps fingerprint pairs with similarity higher than the dynamic similarity threshold, i.e. the shrinkage threshold, to edges in the graph structure and constructs a similarity graph in real time. The smart contract calls the on-chain disjoint-setup algorithm on the similar graph to merge connected nodes from bottom to top. After each merge, the fingerprint with the highest weight is automatically selected as the cluster root of the connected component based on the edge weight. The smart contract calculates a secure hash by combining the current block number and random entropy for each cluster root fingerprint, generating a unique cluster identifier, and stores the cluster identifier and all fingerprints within the cluster in a state table through a bidirectional mapping.

8. The blockchain-based digital copyright registration method for artworks according to claim 7, characterized in that, Registering the artwork with the highest detail score as an original artwork means: The smart contract performs a three-level discrete wavelet decomposition on the complete fingerprint within each fingerprint cluster, calculates the detail energy of each level, and summarizes it into a multi-scale detail score according to preset weights. The smart contract sorts the cluster members from high to low according to the multi-scale detailed scores. If the difference between the highest score and the second highest score is less than the threshold, visual entropy comparison is added to determine the unique first and second place. The smart contract registers the top-ranked artwork as the original artwork and writes the derivative relationship for the remaining artworks in the same cluster in the state mapping table, recording the original identifier, derivative level and timestamp.

Images