System and method for creating and maintaining data immutability, consistency and availability

By transferring trust from third-party services to the blockchain's correctness guarantees, the system addresses throughput and latency issues in blockchain systems, ensuring data immutability, consensus, and availability, enhancing transaction processing efficiency and reliability.

JP2024542873APending Publication Date: 2024-11-15BLOCKY INC
View PDF 1 Cites 0 Cited by

Patent Information

Application Number
JP2024554727
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2022-11-30
Filing Date
2022-12-03
Publication Date
2024-11-15

AI Technical Summary

Technical Problem

Existing blockchain systems face limitations in throughput and latency due to their reliance on decentralized consensus mechanisms, leading to momentary interruptions in system availability and high costs, making decentralized services impractical.

Method used

A blockchain system that transfers user trust from third-party services to the blockchain's correctness guarantees through the use of trusted timestamp, sequencer, and replication services, ensuring data immutability, consensus, and availability by implementing an alternating structure of blocks and timestamp certificates, and using trusted replication services for data stability.

Benefits of technology

The system achieves higher throughput and reliability by leveraging trusted services, providing strong guarantees of data immutability, consensus, and availability, even in the face of network failures, with improved transaction processing times and reduced costs.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2024542873000001_ABST
    Figure 2024542873000001_ABST
Patent Text Reader

Abstract

A method for generating and maintaining data immutability, consensus and availability, the method comprising the steps of: building an alternating structure of blocks and timestamp certificates; determining the order of the blocks; determining which blocks are on the main chain; and replicating all of the blocks, timestamp certificates, sequence certificates and leaves of the Merkle tree using a trusted replication service. A computer program product including a storage device for storing instructions in a persistent manner, the instructions causing a computing device to generate and maintain data immutability, consensus and availability according to the method. A computing device including a processing unit and a memory or other storage device coupled to the processing unit, the memory or other storage device storing instructions, the instructions causing a computing device to create and maintain data immutability, consensus and availability according to the method.
Need to check novelty before this filing date? Find Prior Art

Description

[Technical field]

[0001] [CROSS REFERENCE TO RELATED APPLICATIONS] This application claims priority pursuant to 35 U.S.C. §119(e) to U.S. patent application Ser. No. 63,286,382 (filed December 6, 2021) and U.S. patent application Ser. No. 18,072,574 (filed November 30, 2022).

[0002] [FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT STATEMENT] This invention was made with Government support under Contract No. 2052375 awarded by the National Science Foundation to Blocky, Inc. The Federal Government has certain rights in this invention. [Background technology]

[0003] [Background of the invention] 1. Technical field of the invention The present invention relates generally to the field of distributed ledger technology (blockchain), and more specifically to a system and method for creating and maintaining immutability, consensus and availability of data. Summary of the Invention [Problem to be solved by the invention]

[0004] 2. Description of Related Technology Distributed ledger technologies (DLTs), or blockchains, are enabling a growing number of decentralized alternatives to traditional centralized financial, government, and legal services. Proof-of-work blockchains have only made the development of decentralized services practical due to their high latency, low throughput, and the high and unpredictable costs of recording and executing transactions. New blockchain proposals address these limitations with new consensus mechanisms, faster block distribution techniques, and less speculative transaction pricing [1]–[3]. However, fundamentally, blockchain performance is limited by its reliance on distributed consensus, which appears to play a central role in ensuring the correctness of distributed ledgers.

[0005] Blockchain is a mechanism that ensures immutability, agreement, and availability of data. Blockchain provides immutability by cryptographically linking blocks in a way that makes it nearly impossible to retroactively change them without updating the distributed agreement. Agreement comes from blockchain's distributed consensus protocol, ensuring that the generation of new blocks follows pre-set rules. Finally, availability comes from replicating the blockchain's state across distributed nodes, preventing deletion and, in the case of public blockchains, providing censorship resistance.

[0006] In other words, blockchain achieves its guarantee of correctness by relying on distributed algorithms operating among many nodes separated by a network. If the distributed algorithm needs to maintain a consistent state, but the network is slow, the result is a momentary interruption in the availability of the system [5], which is perceived by users as a decrease in throughput. Although blockchain mechanisms vary, the trade-off between system consistency and availability results in the network performance limiting the throughput of the blockchain.

[0007] This invention proposes to improve performance by rethinking the fundamental trust relationship between a blockchain and its users. Blockchains are considered a trustless peer-to-peer system because users do not need to trust each other to use them, whereas other widely used systems are based on strong (but limited) trust relationships. For example, users typically trust the assertions of a certificate authority's public key. Similarly, authentication services based on OAuth 2.0 [6] are typically trusted to issue correct authentication tokens. Such trust relationships arise from providers' explicit self-interest in the correctness of their services.

[0008] The present invention shows that limited trust in third-party services can give rise to a novel system that produces immutability, consensus, and availability through mechanisms that shift users' trust in these third-party services to trust in the blockchain's correctness guarantees. Specifically, the present invention incorporates (a) the design and implementation of reliable timestamp, sequencer, and replication services, and (b) the design and implementation of a blockchain construction methodology that shifts trust in such services to trust in the blockchain's correctness guarantees. [Means for solving the problem]

[0009] The present invention relates to a method for creating and maintaining immutability, consistency and availability of data, comprising the steps of: The method comprises: constructing an alternating structure of blocks and timestamp certificates; determining an order of the blocks; determining which blocks are on the main chain; replicating, using a trusted replication service, every block, every timestamp certificate, every sequence certificate, and every leaf of the Merkle tree; Including, structuring the alternating structure of blocks and timestamp certificates, constructing a first Merkle tree with leaves of transaction data; generating a first block that includes the root of the first Merkle tree; generating a timestamp certificate for the first block using a trusted timestamp service; constructing a second Merkle tree with leaves of the transaction data; generating a second block that includes the root of the second Merkle tree; linking the second block to the timestamp certificate of the first block; generating a timestamp certificate for the second block using a trusted timestamp service; repeating the above steps for a series of blocks and timestamp certificates to generate an alternating structure in which each block is linked to the timestamp certificate of the previous block; This is carried out by The step of determining the order of the blocks comprises: using a trusted sequencer service to assign each block and its timestamp certificate a sequence certificate, each with a unique number; creating a total order of the blocks based on the height of each block and the sequence certificate assigned to each block; This is carried out by The step of determining which blocks are on the main chain includes: checking the validity of the timestamp certificate for the first block; checking the validity of the sequence certificate for the first block and the validity of the timestamp certificate for the first block; adding the first block and the timestamp certificate for the first block to the main chain; Extending the main chain from the last block included in the main chain that has a sequence certificate; repeating the above steps for the series of blocks, the timestamp certificate, and the sequence certificate; This is carried out by The step of extending the main chain from the last block included in the main chain and having a sequence certificate includes: searching for all successor blocks of the last block, each successor block having a timestamp certificate and a sequence certificate; identifying a successor block that has a sequence certificate that is lower than the sequence certificates of all other successor blocks; checking the validity of the timestamp certificate and the validity of the sequence certificate of the successor block identified in step (c)(iv)(2); When all blocks having sequence certificates are found between the sequence certificate of the last block on the main chain and the sequence certificate of the successor block with the lowest sequence certificate, adding the successor block with the lowest sequence certificate and the timestamp certificate on the successor block with the lowest sequence certificate to the main chain; Includes It is characterized by:

[0010] The invention also relates to a computer program product including a storage device for storing instructions in a persistent manner, which when executed by a processing unit of a computing device cause the computing device to perform steps of creating and maintaining data immutability, consistency and availability using the above-mentioned method. Additionally, the invention also relates to a computing device comprising a processing unit and a memory or other storage device coupled to the processing unit, the memory or other storage device storing instructions when the processing unit is executing, the instructions causing the computing device to perform steps of creating and maintaining data immutability, consistency and availability using the above-mentioned method. [Brief description of the drawings]

[0011] [Figure 1] 1 is a table of definitions of notations used herein. [Diagram 2] A diagram of an AWS Nitro Enclaves parent instance. [Diagram 3] FIG. 1 is a diagram of a blockchain formed in accordance with the present invention. [Figure 4] FIG. 2 is a diagram of a blockchain fork formed in accordance with the present invention. [Diagram 5] FIG. 4 is a flow diagram of a write function of the present invention. [Figure 6] FIG. 2 is a flow diagram of the omc function of the present invention. [Figure 7] FIG. 4 is a flow diagram of the makeCertificate function of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0012] A. Trusted Service The present invention distinguishes itself from distributed blockchain implementations by providing guarantees of immutability, consensus, and availability based on trusted services. This section provides an overview and implementation of trusted timestamps, trusted sequencers, and trusted replication services in the context of the present invention.

[0013] 1. Trusted Timestamps The function of a trusted time stamp service is to provide accurate and reliable time stamps of a physical clock. A time stamp service T is a public / private key pair K. T + / K T - and maintaining an accurate physical clock. The timestamp service provides the following abstract interfaces:

[0014] T := timestamp(y) True / false := validate(K,t)

[0015] The timestamp function takes a byte y as input, reads a physical clock value p, and uses these to generate a timestamp certificate t. The timestamp certificate is a signature g={H(y,p)}_(K_T^-) T - " is a subscript of "{H(y,p)}". The same applies below.) tuple t =<y,p,g> The validate function takes the key K and the timestamp certificate t as input, and checks whether y and p are correctly signed or H(ty,tp)=D K (tg), where D is the decryption function. Note that the operator "." is used for member selection. If the user trusts the timestamp service and validates(K T +If the timestamp() function returns true, then the user can trust that the timestamp service T witnessed the byte ty at time tp. The timestamp function must be run on a trusted timestamp service, but the validate function can be run on any of the following: T + Note that this may be performed by the user, as long as it is well known.

[0016] The present invention implements a timestamp service based on the user authentication service Amazon Cognito (registered trademark) (auth service). The auth service accepts user credentials (username and password) and, if valid, generates a JSON Web Token (JWT). The JWT contains the username, timestamp, and other fields and is signed by the auth service.

[0017] To generate a JWT that is a timestamp authentication of byte y, the present invention performs two steps. First, create a user on the authentication service with a random password: Username = y@bky.sh Second, it authenticates with the authentication service using the username and password and generates a JWT. The resulting JWT is sufficient for timestamp authentication because the JWT contains the username y and the authentication service's timestamp, and both pieces of data are signed by the authentication service. Thus, a user who trusts Amazon Cognito can trust that the byte y was seen by Amazon Web Services® (AWS) at a specific time.

[0018] 2. Trusted Sequencer The function of a trusted sequencer service is to provide sequential numbers for individual events. A sequencer service S has a public / private key pair K S + / K S -and maintains a counter. The sequencer service provides the following abstract interface: s := sequence(y) true / false := check(K,s)

[0019] The sequence function takes as input a byte y representing a unique event ID, increments a counter by 1, records the counter value as k, and produces a sequence certificate s =<y,k,g> where g = {H(y,k)}_(K_S^-) S - ” as a subscript of “{H(y,k)}” (see below). Note that some symbols, such as k, are reused if their meaning can be distinguished by the choice of members. For example, a physical timestamp tk can be distinguished from a sequence number sk because k is a member of a different type. The check function takes as input a key K and a sequence certificate S, and checks whether y and k are correctly signed or whether H(sy,sk)=D K (sg). If the user trusts the sequencer service, check(K S + When ,g) returns true, the user can trust that the unique event, denoted by sy, was witnessed by the sequencer service S as the sk-th event. As with timestamp, the check function S + may be performed by the user as long as the is well known.

[0020] The sequencer service is based on the security and correctness guarantees provided by the AWS Nitro Enclaves™ Trusted Execution Environment (TEE). AWS Nitro Enclaves creates an isolated execution environment within an Amazon EC2™ (Elastic Cloud Compute) instance. It is based on the hypervisor technology from the same company Nitro that provides isolation between Amazon EC2 instances themselves. As shown in Figure 2, inside an Amazon EC2 parent enclave, the enclave runs containers on its own kernel, memory, and virtual CPU (vCPU) resources that are isolated from the parent instance. The enclave has no persistent storage, bidirectional access, or external network. The only way the parent instance can interact with the enclave is through a VSOCK socket. However, the parent instance can proxy requests from the outside world, for example by running a Hypertext Transfer Protocol (HTTP) server. Finally, applications running inside the enclave can request certificates from the Nitro Secure Module (NSM). The certificate contains information about the enclave environment, recorded as a hash of successive measurements of the parent instance ID, the enclave image file (container), and the application requesting the certificate. Optionally, the certificate may contain the enclave's public key and up to 1024 B of user data [7]. The NSM stores the AWS Nitro Enclaves certificate key pair K A + / K A - The certificate is packaged by A +is contained in a well-known root certificate, where the certificate is a Concise Binary Object Representation (CBOR) encoded and CBOR Object Signing and Encryption (COSE) signed object.

[0021] The implementation of a trusted sequencer service on AWS Nitro Enclaves is as follows: Because AWS Nitro Enclaves generates its own certificates, the interface of the sequencer service is changed as follows: a := sequence(y) true / false := check(K,a) Here, the enclave's certificate a contains a sequence certificate s and a signed hash of the image file running on the enclave. To provide a trusted sequencer service, the parent instance runs a gateway that proxies calls to the sequence function running on the enclave S. The sequence request contains a byte y that represents a unique event ID, which serves as an idempotency key inside S.

[0022] Upon receiving a sequence request, the enclave increments a counter in memory and generates a sequence certificate s=<y,k,g> It is important to note that repeated requests for the same sequence do not increment the counter or generate a new sequence certificate; instead, the sequencer service generates a cached<y,k,g> The enclave then requests an enclave proof a from the NSM, where the public key aK=K S + and user data ar = s. Finally, the enclave returns a to the parent instance, which forwards it to the client.

[0023] A client that receives the enclave's certificate a can verify it by calling the check function locally. The check function first checks Amazon's certificate K A + Then, the check function verifies the signature of a on H(ary,ark)=D (a.K) Verify the sequence certificate against the enclave's public key by verifying (arg). If both verifications pass, check(K S + ,a) returns true, at which point the client can trust that event ary has been assigned a sequence number ark by the sequencer service S.

[0024] In our implementation of the sequencer service, the enclave creates a key pair K S + / K S - It is important to note that every enclave generates a sequence certificate, which is distinct between all enclave instances. Therefore, every sequence certificate that an enclave generates is unique, because the enclave uses a different K S - As a result, even if the sequencer service is restarted, S - It is not possible to generate two sequence certificates with the same k for different y signed by

[0025] The final issue is that of user trust. Although a user may trust the AWS Nitro Enclaves system to work correctly, the sequencer service is based on a specific implementation. The implementation's code and build tools are publicly available, so a user can audit the code, build an image, and take the hash of the image, H(I). Note that the enclave's attestation contains a signed hash, H(I'), of the image that will run on the enclave. Thus, if a user trusts the sequencer service implementation, they can verify that the sequence attestation was generated from a trusted implementation by checking H(I) = H(I'). In other words, the hash of the image the user built matches the hash of the image in the enclave's attestation.

[0026] 3. Trusted Replication The function of a trusted replication service is to provide stable storage for data objects. Since storage nodes have a non-zero mean time between failures (MTBF), the stability of the storage is probabilistic and is achieved by replicating data objects across nodes with mostly independent defects. The replication service provides the following abstract interface: Replicate(y) y := fetch(H(y))

[0027] The replicate function takes an object byte y as input and replicates it between storage nodes using H(y) as a search key. The fetch function takes a hash of the object byte H(y) as input and returns the object byte y from one or more replicas.

[0028] In general, the basic model of a distributed system assumes that multiple nodes can access stable storage, implying that protocol data can withstand node failures. In order to assert the correctness of the present invention, the concept of stability needs to be strengthened and made more specific. In this respect, a stable storage service is defined as one that provides durability, immutability, and verifiability. Durability means that a stored object will eventually remain accessible. Immutability means that a stored object will not change in the storage. Verifiability means that a third party can verify that the storage service provides durability and immutability.

[0029] The replication service is implemented based on the correctness guarantees of Write Once, Read Many (WORM) cloud storage systems. WORM systems allow clients to protect stored data against inadvertent modification or deletion in order to meet regulatory requirements for data retention [8]. Specifically, Amazon S3® (Simple Storage Service), Microsoft Azure Blob Storage®, and Google Cloud Storage® guarantee object immutability by enforcing legal / compliance holds on data objects that prevent anyone, including bucket owners, from deleting or modifying the objects [9]-

[11] . The durability of a storage system is often measured as follows: for k>1, time d, k / d is the number of times that the vendor can guarantee (100-100% of a user's data) that the user can access the data for time d. (1-k))% of the data that is retained. For example, Amazon, Microsoft, and Google offer systems that are durable for 11 9s per year by replicating data across availability zones in a region [7],

[12] ,

[13] . Finally, with some custom configuration, cloud storage providers can make bucket settings publicly readable, allowing anyone to verify that object retention is enabled. Alternatively, AWS Nitro Enclaves, which has read-only credentials, can inspect bucket settings and issue publicly verifiable certificates on buckets.

[0030] Although a durability guarantee of 11 nines per year is the industry standard, it is not sufficient for the storage of our objects. To achieve sufficient durability, we employ the following storage scheme. First, the system uses random linear network coding

[14] to encode each object into six shares, so that any three shards can decode the object. Second, the shards are partitioned into six buckets (two buckets per provider) so that all buckets are in different regions. Due to the partitioning, failures can be considered independent. According to the Backblaze® method for calculating durability

[15] , this storage scheme achieves durability of 14 nines over 100 years

[16] .

[0031] 4. Reliability In addition to reliability, our design also requires that the timestamp service, sequencer service, and replication service be reliable in that they can recover from crash failures. While Amazon Cognito and cloud storage services can ensure reliability at the expense of temporary unavailability, AWS Nitro Enclaves cannot do the same. An enclave may crash, but it cannot be restarted because it relies on an internally generated key pair and in-memory state to provide a single sequence certificate. For the remainder of this document, we assume that the sequencer service is reliable at the expense of not being able to sequence new blocks if the sequencer service fails.

[0032] B. Detailed Description of the Invention The present invention creates a new blockchain that provides immutability, consensus, and availability based on users' (limited but strong) trust in the services of timestamps, sequences, and replication. The key innovation of the present invention is the structure and construction process of the chain that transfers users' trust in these services to trust in the correctness guarantees of the present invention.

[0033] Figure 3 shows our data representation. Let m be a Merkle tree. Note that H(m) is overloaded to mean the root of the tree (not the hash of the whole tree). A block contains the root of the Merkle tree, which is generated from the set of leaves that contain transaction data. For a block b, the height of b is the number of blocks on the path from b to b0. For convenience, we call block b of height i b i and its height is bi. Block b i b i .m H =H(m i ) as the root m of the Merkle tree iThe block also contains a Universally Unique IDentifier (UUID)

[17] field u that is assigned when the block is created.

[0034] The physical timestamp of each block is obtained from a timestamp certificate created by a trusted timestamp service. For example, timestamp certificate t i t i .y=H(b i ) as block b i To link each timestamp certificate to the next block, (i+1) b (i+1) .t H =H(t i ) as t i Contains a hash of.

[0035] The sequence number of each block is obtained from a sequence certificate created by a trusted sequencer service. For example, the kth sequence certificate s k (a k (inside) block b i To facilitate branching in the validation process, k sends both the block and its timestamp certificate to s k .y=b i .u++H((t i ). The operator "++" is used for concatenation.

[0036] It is possible for multiple chains to coexist. Our chains can be distinguished by the blocks zero b0 and b'0 (uniquely UUID) associated with a particular sequencer service instance. The instance is bound to a unique public key K generated at the start-up of S and S', respectively. S + and K S ' +Just as a user can trust the correctness of a single chain, multiple chains can trust each other's correctness. However, total ordering of transactions is preserved within a chain, not across chains.

[0037] The inventive structure guarantees immutability, consensus, and availability. Each of these guarantees is described in detail below, followed by a description of the inventive implementation.

[0038] 1. Immutability The invention ensures immutability through an alternating structure of blocks and timestamp certificates that fit together like the teeth of a zipper. The timestamp certificate provides a third-party trusted signature on a hash of a block that contains a Merkle root, constructed from a sequence of transactional data, also called a transaction. Any changes to these transactions can be detected as a mismatch between the block hash and the bytes signed by the timestamp certificate. Thus, as long as the timestamp certificate remains part of the chain, the block remains immutable.

[0039] The timestamp certificate remains in the chain because the next block contains its hash, so the certificate at the end of the chain signs that block, and also the certificate before it, and indirectly signs that block, and so on.

[0040] A user who believes a block belongs to a described blockchain instance can be confident of the block's integrity by verifying the block's timestamp certificate. Users can also verify the integrity of the chain by verifying the preceding blocks and certificates for a particular chain instance, all the way up to the well-known block zero.

[0041] 2. Agreeableness The present invention ensures consensus by detecting and eliminating chain forks, ensuring that all users see the same total ordered set of blocks, and therefore transactions. A fork is a chain of chains that have the same block height i>0 and are the same as the previous block b i-1 Two blocks b i and b' i FIG. 4 shows the branching of a chain generated by the present invention. In the figure, block b i and b' i is the same as the previous timestamp certificate t i-1 and pass block b i-1 It refers to...

[0042] Forks are problematic in blockchain because they can introduce inconsistencies into the state of an application represented on the blockchain. For example, two users send incompatible transactions d and d'. If there were no forks in the chain, any client reading the blockchain would see the same consistent history, within the same block or across different blocks, where d precedes d'. Then, according to the rules of the application, transaction d would be applied to that state and d' would be ignored. On the other hand, if d and d' were to appear in the forked block b, i and b' i , it is not clear how to order d and d' to determine which transactions to apply and which to ignore.

[0043] Forks also cause another problem specific to the present invention. A user verifying the integrity of a described instance of the blockchain by tracing the blockchain backwards from a block may not know whether the block encountered is on the main chain or on a fork. This uncertainty is problematic because transactions in blocks on a fork are not considered valid by users tracing the main chain. In addition, a forked block may be maliciously deleted without users on the main chain detecting the deletion.

[0044] We detect forks by creating a total order of all blocks (blocks on the main chain and blocks on all forks) using the block heights and sequence certificates. We find a 2-tuple of the corresponding block, timestamp, and enclave certificate (including the sequence certificate) such that ary=b.u++H(t) and a'.ry=b'.u++H(t').<b,t,a> and<b',t',a'> Given, the ordering relation (→) is defined as follows: (b,a)→(b',a')⇔bi <b'.i∨(b.i=b'.i  ∧  a.r.k<a'.r.k)

[0045] For example, the total order of the block and enclave certificate pairs in Figure 4 is (b i-1 ,a k-1 )→(b i ,a k )→(b' i ,a k+1 )→(b' i+1 ,a k+2 )→(b i+1 ,a k+3 ). In the case of a fork, users use two rules to determine which block is on the main chain. First, a block is on the main chain only if its parent is on the main chain. Second, if multiple blocks have parents on the main chain, the lowest-order block is on the main chain. For example, according to Figure 4, b i-1Assume that is on the main chain and the fork begins at block height i. At the beginning of the fork, (b i ,a k ) and (b' i ,a k+1 ), the user can choose (b i ,a k )→(b' i ,a k+1 ) to determine which block is on the main chain. This means (deterministically) that i means that b' is on the main chain, i This means that b is not on the main chain. i If is on the main chain, then (b' i+1 ,a k+2 )→(b i+1 ,a k+3 ), the user can still i+1 It can be deterministically determined that b is on the main chain because i+1 The front of is on the main chain, but b' i+1 This is because the value before is not on the main chain.

[0046] 3.Availability The present invention provides strong, probabilistic guarantees on data availability by increasing the distribution of blocks, timestamp certificates, sequencer certificates, and leaves of the Merkle tree through the use of a trusted replication service. Data replication using a trusted replication service generates redundant shards of data distributed among independently failed replicas. As a result, encoded data remains available even if some replicas become unavailable. Even if a sufficient number of replicas become temporarily unavailable, users can still have confidence that their stored data is intact and will be available again, due to the high durability guarantees of the trusted replication service. The present invention is important in that it records transaction data in such a way that users can verify immutability and consensus on blockchain transactions, even if other trusted services or blockchain creation mechanisms become unavailable, as long as the guarantees of the trusted replication service remain.

[0047] 4. Implementation The present invention provides the following abstract interfaces: Write(d) f := verify(b0,K S + ,K T + ,H(d))

[0048] The write function takes as input the transaction data d and starts the process of recording d in the instance of the described blockchain invention. The verify function returns the chain with the first block (genesis block) b0 and the public key K of the sequence service. S + and the public key K of the time stamp service T + and returns a certificate f that takes the transaction hash H(d) as input. This certificate f verifies that the transaction exists in the last block on the chain whose first block is b0. This certificate contains the transaction hash d HIt contains two timestamps, -t and _t, which represent the upper and lower limits of transaction acceptance, and a chain field b0. When a user trusts the verify function, the user knows that transaction d will be written to the chain between -t and _t and will remain unchanged on that chain.

[0049] a. Recording of transactions 5 shows a process for implementing the write function in the present invention. The numbering in the following description of the process corresponds to the numbering of the arrows in FIG.

[0050] 1. To sign a transaction d, a user calls write(d). The BatchIt service receives d and enqueues the write request internally. 2. Periodically, the ZipIt service asks BatchIt for a batch of write requests. BatchIt dequeues the set of requests and creates a batch, identified by a batch ID c. BatchIt then creates a Merkle tree m, where each leaf is transaction data d from a write request in the batch. BatchIt then sends tuples<c,m> Reply with.

[0051] 3. Upon receiving a batch from BatchIt, the ZipIt service will <u,m H ,t H > where u is the newly generated UUID and m H =H(m) is the root of the Merkle tree, and t H =H(t i-1 ) is a hash of the previous timestamp certificate. The start of the blockchain is the well-known block zero b0 and its corresponding timestamp certificate t0. Therefore, ZipIt always i-1Then ZipIt calls the timestamp function of a trusted timestamp service, passing it the hash of the block H(b). The certificate service generates a timestamp certificate t i =<y,p,g> where y=H(b) and g={H(y,p)}_(K_T^-). Finally, ZipIt returns t as t i-1 and include that hash in the next block.

[0052] 4.ZipIt sends the tuple to the StoreIt service.<c,m,b,t> Send. 5.StoreIt for duplicate tuples<m,b,t> to the replication service. StoreIt will not proceed to the next step until the replication service confirms that it has successfully replicated the tuple. 6. Once a block has been replicated, it is safe to give it a sequence number. StoreIt sends the unique ID of block bu combined with the hash of the certificate H(t) for timestamp t to the sequencer service. The sequencer service then creates the sequence certificate s=<b.u++H(t),k,g> , where g = {H(b.u++H(t),k)}_(K_S^-).

[0053] 7. The StoreIt service passes the enclave certificate a to the replication service for replication. Once the replication of the enclave certificate is complete, all transactions in the block are finalized. 8. Finally, StoreIt sends the batch ID c to BatchIt, informing it that the blocks corresponding to the requested batch have been replicated, allowing BatchIt to delete the batch.

[0054] It is important to note that the write function does not guarantee that the transaction has been recorded in the blockchain. After step 1, the write function returns, informing the user that the transaction has been accepted for processing. The user only knows that the transaction has been recorded in the blockchain after the verify function returns a certificate. The user can only expect verify to give a correct result for the transaction after the transaction has been finalized.

[0055] b. Transaction Verification After calling the write function for a transaction, the user must verify that the transaction has been written to the blockchain, i.e., that the transaction exists in a confirmed block on the main chain. The verification process proceeds as follows:

[0056] 1. To verify a transaction, a user executes verify(b0,K S + ,K T + , H(d)). The call includes the transaction data d, information identifying the blockchain, i.e., block zero b0, and the public key K of the sequencer service. S + , and the public key K of the time stamp service T + As previously mentioned, the verify function can be performed on the user's machine, so the user does not need to trust that the organization implementing the invention will perform the function correctly.

[0057] 2. The verify function downloads the current state of the blockchain from the replica service. Specifically, this state includes a set of blocks (B), Merkle trees (M), timestamp certificates (T), and enclave certificates (A). In practice, these sets, and the validation described below, may be cached (bootstrapped) and expanded as the chain grows.

[0058] 3. Next, the verify function determines which blocks and timestamp certificates are on the main chain. To do so, it calls the function omc shown in Figure 6. The function creates a set Z=omc(b0,K S + ,K T + , B, T, A).

[0059] 4. Finally, the verify function determines whether a block on the main chain contains the transaction data d. We assume that transactions are idempotent and their hashes are unique. Therefore, the certificate of a transaction is always related to its first instance. To generate a certificate, verify calls the makeCertificate function shown in Figure 7. The function creates a certificate f = makeCertificate(b0,K S + ,H(d),M,Z). If f ≠ the empty set, verify returns a certificate to the user.

[0060] When the verify function returns a certificate f, it validates that the transaction data d exists at time f. - It asserts that the transaction existed on a chain with genesis block b0 before t and after time f._t. When verify returns a certificate, it also states that the transaction is final and will not be modified on the blockchain.

[0061] Let the certificates for transaction data a and a' be f and f' respectively, and the hash f._t.b H Let the block with be b, and the hash f'._t.b H Let the block with be b'. b.i < b'.i or b.i = b'.i, and H(m) = b.m H Advance data d to d' only when d is to the left of d' in the leaf of Merkle tree m such that

[0062] 5. Advantages over the prior art The design of the initial blockchain such as Bitcoin

[18] was made possible by Proof-of-Work (PoW) and Nakamoto's probabilistic consensus. Miners solve cryptographic puzzles to generate new blocks, guess the nonce which is its hash, and other parts of the blockchain, and generate a hash that is small enough when considered as a binary number. This mechanism has been proven to be resistant to organized attacks, but it is costly in terms of the power consumed by mining hardware. To address the mining cost of new blocks, Peercoin (registered trademark)

[19] was the first to adopt Proof-of-Stake (PoS). In this method, the opportunity to generate the next block is determined by a lottery weighted by the number of coins staked by validator nodes rather than the hash power of the nodes. In many cases, correctness is enforced by the Byzantine Fault Tolerant (BFT) consensus mechanism. Due to both the PoW and PoS designs, many established public blockchains have emerged

[18] ,

[20] .

[0063] The performance limiting factor for these blockchains is the network performance between miner / validator nodes

[20] . It simply takes time for validators to disseminate new blocks so that they can generate successors rather than forks. The interval between blocks is determined by the size of the block, the interval between blocks, and the performance of the network. For example, while it may be natural to worry about block processing time when faced with complex smart contracts, the processing speed of validators has not been a limiting factor for blockchain performance so far [2], [4].

[0064] To achieve higher performance, DLT designs have two directions. The first direction is to reduce the block interval and transaction recording delay, mainly by using small blocks that do not take long to spread. The second direction is to increase transaction throughput, mainly by relying on a constrained number of well-connected validating nodes. Some blockchains combine these two approaches

[21] ,

[22] .

[0065] In the first direction, decreasing the block interval can result in blocks that are very small and contain only a few transactions. However, blocks can reference multiple (usually two) previous blocks, forming a directed acyclic graph (DAG) [1],

[21] -

[23] . In a DAG, blocks at the same height in the DLT do not necessarily fork, since branches can be merged in subsequent blocks. Transaction confirmation still depends on consensus among a quorum of nodes, but nodes reach consensus independently for each transaction. Independent consensus tends to speed up transaction latency, but not necessarily throughput.

[0066] In the second direction, when limiting the number of validators, the high-capacity direct connections between them improve the rate of block dissemination. DLTs can identify validators by delegation

[21] or by a technique called Proof of Authority (PoA)

[24] ,

[25] . In PoA, validators stake their reputation to follow the protocol. If they do not follow the protocol, they lose their reputation and with it the right to produce future blocks. Unfortunately, in most systems, it is not clear how to quantify reputation.

[0067] The present invention may be characterized as a "delegated" PoA insofar as it transfers the reputation of dependent services, such as Amazon Cognito, Amazon S3, and AWS Nitro Enclaves, to the blockchain mechanism. With delegation, there are multiple metrics to quantify reputation; for example, users, revenue, number of projects using the service, etc. With delegated PoA, the key observation is that the dependent services have already staked their reputation, independent of the present invention. That is, if a service like Amazon Cognito deviates from its protocol, its reputation will sink, resulting in loss of users, revenue, etc.

[0068] A key feature of our delegated PoA blockchain is that its throughput depends on the performance of the network between its component services, as shown in Figure 5. Because the component services may all be located in the cloud, their connections can approach line speed, orders of magnitude faster than the interconnections of more decentralized blockchain architectures. As a result, subject to certain transaction confirmations, our throughput is orders of magnitude higher.

[0069] While preferred embodiments of the present invention have been shown and described, it will be apparent to those skilled in the art that many changes and modifications can be made therein without departing from this invention in its broader aspects, and it is therefore intended in the appended claims to cover all such changes and modifications which fall within the true spirit and scope of this invention.

Claims

1. 1. A method for creating and maintaining immutability, consistency and availability of data, comprising: The method comprises: (a) constructing an alternating structure of blocks and timestamp certificates; (b) determining an order of the blocks; (c) determining which blocks are on the main chain; (d) replicating, using a trusted replication service, every block, every timestamp certificate, every sequence certificate, and every leaf of the Merkle tree; Including, (a) constructing an alternating structure of blocks and timestamp certificates, (i) constructing a first Merkle tree having leaves of transaction data; (ii) generating a first block that includes the root of the first Merkle tree; (iii) generating a timestamp certificate for the first block using a trusted timestamp service; (iv) constructing a second Merkle tree with leaves of the transaction data; (v) generating a second block that includes the root of the second Merkle tree; (vi) linking the second block to the timestamp certificate of the first block; (vii) generating a timestamp certificate for the second block using a trusted timestamp service; (viii) repeating steps (a)(i) through (a)(vii) for a series of blocks and timestamp certificates to generate an alternating structure in which each block is linked to the timestamp certificate of the immediately preceding block; This is carried out by The step (b) of determining the order of the blocks includes: (i) using a trusted sequencer service to assign to each block and its timestamp certificate a sequence certificate, each having a unique number; (ii) creating a total order of the blocks based on each block's height and the sequence certificate assigned to each block; This is carried out by The step (c) of determining which blocks are on the main chain includes: (i) checking the validity of the timestamp certificate for the first block; (ii) checking the validity of the sequence certificate for the first block and the validity of the timestamp certificate for the first block; (iii) adding the first block and the timestamp certificate for the first block to the main chain; (iv) extending the main chain from the last block included in the main chain and having a sequence certificate; (v) repeating steps (c)(iv)(1) through (c)(iv)(4) for the series of blocks, the timestamp certificate, and the sequence certificate; This is carried out by The step (c)(iv) (A) searching for all successor blocks of the last block, each successor block having a timestamp certificate and a sequence certificate; (B) identifying a successor block that has a sequence certificate that is lower than the sequence certificates of all other successor blocks; (C) checking the validity of the timestamp certificate and the validity of the sequence certificate of the successor block identified in step (c)(iv)(2); (D) when all blocks having sequence certificates are found between the sequence certificate of the last block on the main chain and the sequence certificate of the successor block with the lowest sequence certificate, adding the successor block with the lowest sequence certificate and the timestamp certificate on the successor block with the lowest sequence certificate to the main chain; carried out by A method comprising:

2. 1. A computer program product including a memory device for storing instructions in a persistent manner, comprising: When executed by a processing unit of a computing device, the instructions cause the computing device to perform steps to create and maintain data immutability, consistency, and availability; The step of generating and maintaining the immutability, consistency and availability of the data comprises: (a) constructing an alternating structure of blocks and timestamp certificates; (b) determining an order of the blocks; (c) determining which blocks are on the main chain; (d) replicating, using a trusted replication service, every block, every timestamp certificate, every sequence certificate, and every leaf of the Merkle tree; Including, (a) constructing an alternating structure of blocks and timestamp certificates, (i) constructing a first Merkle tree having leaves of transaction data; (ii) generating a first block that includes the root of the first Merkle tree; (iii) generating a timestamp certificate for the first block using a trusted timestamp service; (iv) constructing a second Merkle tree with leaves of the transaction data; (v) generating a second block that includes the root of the second Merkle tree; (vi) linking the second block to the timestamp certificate of the first block; (vii) generating a timestamp certificate for the second block using a trusted timestamp service; (viii) repeating steps (a)(i) through (a)(vii) for a series of blocks and timestamp certificates to generate an alternating structure in which each block is linked to the timestamp certificate of the immediately preceding block; This is carried out by The step (b) of determining the order of the blocks includes: (i) using a trusted sequencer service to assign to each block and its timestamp certificate a sequence certificate, each having a unique number; (ii) creating a total order of the blocks based on each block's height and the sequence certificate assigned to each block; This is carried out by The step (c) of determining which blocks are on the main chain includes: (i) checking the validity of the timestamp certificate for the first block; (ii) checking the validity of the sequence certificate for the first block and the validity of the timestamp certificate for the first block; (iii) adding the first block and the timestamp certificate for the first block to the main chain; (iv) extending the main chain from the last block included in the main chain and having a sequence certificate; (v) repeating steps (c)(iv)(1) through (c)(iv)(4) for the series of blocks, the timestamp certificate, and the sequence certificate; This is carried out by The step (c)(iv) (A) searching for all successor blocks of the last block, each successor block having a timestamp certificate and a sequence certificate; (B) identifying a successor block that has a sequence certificate that is lower than the sequence certificates of all other successor blocks; (C) checking the validity of the timestamp certificate and the validity of the sequence certificate of the successor block identified in step (c)(iv)(2); (D) when all blocks having sequence certificates are found between the sequence certificate of the last block on the main chain and the sequence certificate of the successor block with the lowest sequence certificate, adding the successor block with the lowest sequence certificate and the timestamp certificate on the successor block with the lowest sequence certificate to the main chain; carried out by 23. A computer program product comprising:

3. 1. A computing device comprising a processing unit and a memory or other storage device coupled to the processing unit, The memory or other storage device stores instructions that, when executed by the processing unit, cause the computing device to perform steps to create and maintain data immutability, consistency, and availability; The step of generating and maintaining the immutability, consistency and availability of the data comprises: (a) constructing an alternating structure of blocks and timestamp certificates; (b) determining an order of the blocks; (c) determining which blocks are on the main chain; (d) replicating, using a trusted replication service, every block, every timestamp certificate, every sequence certificate, and every leaf of the Merkle tree; Including, (a) constructing an alternating structure of blocks and timestamp certificates, (i) constructing a first Merkle tree having leaves of transaction data; (ii) generating a first block that includes the root of the first Merkle tree; (iii) generating a timestamp certificate for the first block using a trusted timestamp service; (iv) constructing a second Merkle tree with leaves of the transaction data; (v) generating a second block that includes the root of the second Merkle tree; (vi) linking the second block to the timestamp certificate of the first block; (vii) generating a timestamp certificate for the second block using a trusted timestamp service; (viii) repeating steps (a)(i) through (a)(vii) for a series of blocks and timestamp certificates to generate an alternating structure in which each block is linked to the timestamp certificate of the immediately preceding block; This is carried out by The step (b) of determining the order of the blocks includes: (i) using a trusted sequencer service to assign to each block and its timestamp certificate a sequence certificate, each having a unique number; (ii) creating a total order of the blocks based on each block's height and the sequence certificate assigned to each block; This is carried out by The step (c) of determining which blocks are on the main chain includes: (i) checking the validity of the timestamp certificate for the first block; (ii) checking the validity of the sequence certificate for the first block and the validity of the timestamp certificate for the first block; (iii) adding the first block and the timestamp certificate for the first block to the main chain; (iv) extending the main chain from the last block included in the main chain and having a sequence certificate; (v) repeating steps (c)(iv)(1) through (c)(iv)(4) for the series of blocks, the timestamp certificate, and the sequence certificate; This is carried out by The step (c)(iv) (A) searching for all successor blocks of the last block, each successor block having a timestamp certificate and a sequence certificate; (B) identifying a successor block that has a sequence certificate that is lower than the sequence certificates of all other successor blocks; (C) checking the validity of the timestamp certificate and the validity of the sequence certificate of the successor block identified in step (c)(iv)(2); (D) when all blocks having sequence certificates are found between the sequence certificate of the last block on the main chain and the sequence certificate of the successor block with the lowest sequence certificate, adding the successor block with the lowest sequence certificate and the timestamp certificate on the successor block with the lowest sequence certificate to the main chain; carried out by A computing device comprising:

Citation Information

Patent Citations

  • Attestation service for use with a blockchain network

    WO2021165755A1