US20220058622A1 - Protocols in Blockchain Environments - Google Patents

Abstract

A protocol cost effectively separates any blockchain (such as the Bitcoin blockchain) from any cryptocurrency (such as the Bitcoin cryptocurrency). The protocol provides client-defined Chains of Entries, client-side validation of Entries, a distributed consensus algorithm for recording the Entries, and a blockchain anchoring approach for security.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS
• This patent application is a continuation filing of U.S. application Ser. No. 16/351,597 filed Mar. 13, 2019, since issued as U.S. Patent X, which claimed domestic benefit of U.S. Provisional Application No. 62/714,909 filed Aug. 6, 2018, with both patent applications incorporated herein by reference in their entireties. This patent application relates to U.S. application Ser. No. 15/983,572 filed May 18, 2018 and incorporated herein by reference in its entirety. This patent application also relates to U.S. application Ser. No. 15/983,595 filed May 18, 2018 and incorporated herein by reference in its entirety. This patent application also relates to U.S. application Ser. No. 15/983,612 filed May 18, 2018 and incorporated herein by reference in its entirety. This patent application also relates to U.S. application Ser. No. 15/983,632 filed May 18, 2018 and incorporated herein by reference in its entirety. This patent application also relates to U.S. application Ser. No. 15/983,655 filed May 18, 2018 and incorporated herein by reference in its entirety.
BACKGROUND
• In today's global economy, trust is in rare supply. This lack of trust requires the devotion of a tremendous amount of resources to audit and to verify records—reducing global efficiency, return on investment, and prosperity. Moreover, incidents such as the 2010 United States foreclosure crisis demonstrate that in addition to being inefficient, the current processes are also terribly inaccurate and prone to failure.
BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS
• The features, aspects, and advantages of the exemplary embodiments are understood when the following Detailed Description is read with reference to the accompanying drawings, wherein:
• FIGS. 1-8 illustrate a Factom protocol and system, according to exemplary embodiments;
• FIGS. 9-21 are simplified illustrations of a digital contract in a blockchain environment, according to exemplary embodiments;
• FIGS. 22-24 are more detailed illustrations of an operating environment, according to exemplary embodiments;
• FIGS. 25-29 illustrate a blockchain data layer, according to exemplary embodiments;
• FIGS. 30-32 further illustrate the digital contract, according to exemplary embodiments;
• FIGS. 33-35 illustrate an access mechanism, according to exemplary embodiments;
• FIG. 36 illustrates a public entity, according to exemplary embodiments;
• FIGS. 37-40 illustrate contractual execution, according to exemplary embodiments;
• FIGS. 41-42 illustrate virtual execution, according to exemplary embodiments;
• FIG. 43 illustrates cryptographic affinities, according to exemplary embodiments;
• FIG. 44 illustrates virtual assignments based on the blockchain data layer, according to exemplary embodiments;
• FIGS. 45-51 illustrate an architectural scheme, according to exemplary embodiments;
• FIG. 52 illustrates compliance scheme, according to exemplary embodiments;
• FIGS. 53-59 illustrate a decisional architecture and scheme, according to exemplary embodiments;
• FIG. 60 is a flowchart illustrating a method or algorithm for executing of digital contracts, according to exemplary embodiments; and
• FIGS. 61-63 depict still more operating environments for additional aspects of the exemplary embodiments.
DETAILED DESCRIPTION
• The exemplary embodiments will now be described more fully hereinafter with reference to the accompanying drawings. The exemplary embodiments may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. These embodiments are provided so that this disclosure will be thorough and complete and will fully convey the exemplary embodiments to those of ordinary skill in the art. Moreover, all statements herein reciting embodiments, as well as specific examples thereof, are intended to encompass both structural and functional equivalents thereof. Additionally, it is intended that such equivalents include both currently known equivalents as well as equivalents developed in the future (i.e., any elements developed that perform the same function, regardless of structure).
• Thus, for example, it will be appreciated by those of ordinary skill in the art that the diagrams, schematics, illustrations, and the like represent conceptual views or processes illustrating the exemplary embodiments. The functions of the various elements shown in the figures may be provided through the use of dedicated hardware as well as hardware capable of executing associated software. Those of ordinary skill in the art further understand that the exemplary hardware, software, processes, methods, and/or operating systems described herein are for illustrative purposes and, thus, are not intended to be limited to any particular named manufacturer.
• As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless expressly stated otherwise. It will be further understood that the terms “includes,” “comprises,” “including,” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. It will be understood that when an element is referred to as being “connected” or “coupled” to another element, it can be directly connected or coupled to the other element or intervening elements may be present. Furthermore, “connected” or “coupled” as used herein may include wirelessly connected or coupled. As used herein, the term “and/or” includes any and all combinations of one or more of the associated listed items.
• It will also be understood that, although the terms first, second, etc. may be used herein to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. For example, a first device could be termed a second device, and, similarly, a second device could be termed a first device without departing from the teachings of the disclosure.
• FIG. 1 illustrates a distributed, autonomous Factom protocol, according to exemplary embodiments. The Factom protocol cost effectively separates any blockchain (such as the Bitcoin blockchain) from any cryptocurrency (such as the Bitcoin cryptocurrency). The Factom protocol provides client-defined Chains of Entries, client-side validation of Entries, a distributed consensus algorithm for recording the Entries, and a blockchain anchoring approach for security.
• When Satoshi Nakamoto launched the Bitcoin blockchain he revolutionized the way transactions were recorded. There had never before existed a permanent, decentralized, and trustless ledger of records. Developers have rushed to create applications built on top of this ledger. Unfortunately, they have been running into a few core constraints intrinsic to the original design tradeoffs of Bitcoin.
• • 1) Speed—because of the design of the decentralized, proof-of-work consensus method used by Bitcoin, difficulty requirements are adjusted to maintain roughly 10 minute confirmation times. For applications that wish greater security, multiple confirmations may be required. A common requirement is to wait for 6 confirmations, which can lead to wait times over an hour.
  • 2) Cost—the default transaction cost is around 0.01 mBTC (roughly $0.003 USD in November 2014, and as much as $80 USD per transaction at times in 2017). The exchange price of BTC has been volatile throughout its history. If the price of BTC rises, then the cost of transactions can go up. This can prove to be a serious cost barrier to applications that need to manage very large numbers of transactions. Additionally, many factors including constraints on block size and reward halving could act to increase transaction fees.
  • 3) Bloat—with the Bitcoin blockchain size limit of 1 MB per block, transaction throughput is capped at 7 transactions per second. Any application that wants to write and store information using the blockchain will add to the traffic. This problem has become politically charged as various parties seek to increase the block size limit and are met with resistance from those concerned about decentralization.
• Factom is a protocol designed to address these three core constraints. Factom creates a protocol for Applications that provide functions and features beyond currency transactions. Factom constructs a standard, effective, and secure foundation for these Applications to run faster, cheaper, and without bloating Bitcoin.
• Once the system is set up, including issuance of Factoids (i.e., the cryptocurrency of Factom) and user accounts, token value is transferred among users, Factom, and Bitcoin with the following primary interactions:
• 1. Application Owner purchases Entry Credits with Factoid
• 2. Application records an Entry
• 3. Factom Servers create Entry Blocks and Directory Blocks
• 4. Factom secures an anchor (hash of the Directory Block) onto the blockchain
• Details of these and other interactions are in the upcoming sections.
• The Factom protocol secures entries. Factom extends Bitcoin's feature set to record events outside of monetary transfers. Factom has a minimal ruleset for adding permanent Entries. Factom pushes most data validation tasks to the client side. The only validation Factom enforces are those required by the protocol to trade Factoids, convert Factoids to Entry Credits, and to ensure Entries are properly paid for and recorded.
• • Factom has a few rules regarding token incentives for running the network and for internal consistency, but Factom may or may not check the validity of statements recorded in the chains used by its users.
• Bitcoin limits transactions to those moving value from a set of inputs to a set of outputs. Satisfying the script required of the inputs (generally requiring certain signatures) is enough for the system to ensure validity. This is a validation process that can be automated, so the auditing process is easy. If Factom were used, for instance, to record a deed transfer of real estate, Factom would be used to simply record the process occurred. The rules for real estate transfers are very complex. For example, a local jurisdiction may have special requirements for property if the buyer is a foreigner, farmer, or part time resident. A property might also fall into a number of categories based on location, price, or architecture. Each category could have its own rules reflecting the validation process for smart contracts. In this example, a cryptographic signature alone is insufficient to fully verify the validity of a transfer of ownership. Factom then is used to record the process occurred rather than validate transfers.
• Bitcoin miners perform two primary tasks. First, they resolve double spends. Seeing two conflicting transactions that spend the same funds twice, they resolve which one is admissible. The second job miners perform (along with the other full nodes) is auditing. Since Bitcoin miners only include valid transactions, one that is included in the blockchain can be assumed to have been audited. A thin client does not need to know the full history of Bitcoin to see if value they receive has already been spent.
• Factom splits the two roles that Bitcoin miners do into two tasks: 1—recording Entries in a final order and 2—auditing Entries for validity.
• • 1—The Factom servers accept Entries, assemble them into blocks, and fix their order. After 10 minutes, the Entry ordering is made irreversible by inserting an anchor into the Bitcoin blockchain. Factom does this by creating a hash of the data collected over the 10 minutes, then recording the hash into the blockchain.
  • 2—The auditing of Entries is a separate process which can be done either with or without trust. Auditing is critical, since Factom is not able to validate Entries before they are included in the Factom dataset.
• With trust-based auditing, a thin client could trust a competent auditor they choose. After an Entry was entered into the system, an auditor would verify the Entry was valid. Auditors would submit their own cryptographically signed Entry. The signature would show that the Entry passed all the checks the auditor deemed was required. The audit requirements could in fact be part of a Factom Chain as well. In the real estate example from earlier, the auditor would double check the transfer conformed to local standards. The auditor would publicly attest that the transfer was valid.
• Trustless auditing would be similar to Bitcoin. If a system is internally consistent with a mathematical definition of validity like Bitcoin, it can be audited programmatically. If the rules for transfer were able to be audited by a computer, then an Application could download the relevant data and run the audit itself. The application would build an awareness of the system state as it downloaded, verified, and decided which Entries were valid or not.
• Mastercoin, Counterparty, and Colored Coins have a similar trust model. These are all client-side validated protocols, meaning transactions are embedded into the Bitcoin blockchain. Bitcoin miners do not audit them for validity; therefore, invalid transactions designed to look like transactions on these protocols can be inserted into the blockchain. Clients that support one of these protocols scan through the blockchain and find potential transactions, check them for validity, and build an interpretation of where the control of these assets lie (usually a Bitcoin address). It is up to the clients to do their own auditing under these protocols.
• Moving any of these client-side validated protocols under Factom would be a matter of defining a transaction per the protocol and establishing a Chain to hold the transactions. The transaction protocols wouldn't be much different under Factom than under Bitcoin, except where Factom allows an easy expression of the information needed instead of having to encode it in some special way into a Bitcoin transaction.
• Bitcoin, land registries, and many other systems need to solve a fundamental problem: proving a negative. They prove some “thing” has been transferred to one person, and prove that thing hasn't been transferred to someone else. While proof of the negative is impossible in an unbounded system, it is quite possible in a bounded system. Blockchain based cryptocurrencies solve this problem by limiting the places where transactions can be found. Bitcoin transactions can only be found in the Bitcoin blockchain. If a relevant transaction is not found in the blockchain, it is defined from the Bitcoin protocol perspective not to exist and thus the BTC hasn't been sent twice (double spent).
• Certain land ownership recording systems are similar. Assume a system where land transfer is recorded in a governmental registry and where the legal system is set up so that unrecorded transfers are assumed invalid (sans litigation). If an individual wanted to check if a title is clear (i.e., that no one else claims the land) the answer would be in the governmental registry. The individual using the government records could prove the negative; the land wasn't owned by a third party. Where registration of title is not required, the governmental registry could only attest to what has been registered. A private transfer might very well exist that invalidates the understanding of the registry.
• In both of the above cases, the negative can be proven within a context. With Mastercoin the case is very strong. With a land registry, it is limited to the context of the Registry, which may be open to challenge. The real world is messy, and Factom is designed to accommodate not just the precision of digital assets, but the real world's sometimes messy reality.
• In Factom, there is a hierarchy of data categorization. Factom only records Entries in Chains; the various user-defined Chains have no dependencies that Factom enforces at the protocol level. This differs from Bitcoin, where every transaction is potentially a double-spend, and so it must be validated. By organizing Entries into Chains, Factom allows Applications to have smaller search spaces than if all Factom data were combined together into one ledger.
• If Factom were to be used to manage land transfers, an Application using a Chain to record such registries could safely ignore Entries in the other Chains, such as those used to maintain security camera logs. Were a governmental court ruling to change a land registration, the relevant Chain would be updated to reflect the ruling. The history would not be lost, and where such changes are actually invalid from a legal or other perspective, the record cannot be altered to hide the order of events in Factom.
• Factom may or may not validate Entries; Entries are instead validated client-side by users and Applications. As long as an Application understands and knows the rules a Chain should follow, then the existence of invalid Entries doesn't cause unreasonable disruption. Entries in a Chain that do not follow the rules can be disregarded by the Application.
• Users can use any set of rules for their Chains, and any convention to communicate their rules to the users of their Chains. The first Entry in a Chain can hold a set of rules, a hash of an audit program, etc. These rules then can be understood by Applications running against Factom to ignore invalid Entries client-side.
• An enforced sequence can be specified. Entries that do not meet the requirements of the specified enforced sequence will be rejected. However, Entries that might be rejected by the rules or the audit program will still be recorded. Users of such chains will need to run the audit program to validate a chain sequence of this type. The Factom servers will not validate rules using the audit program.
• Validation in the Applications (in combination with user-defined Chains) provides a number of advantages for Applications written on top of Factom:
• • 1) Applications can put into Factom whatever Entries make sense for their application. So, a list of hashes to validate a list of account statements can be recorded as easily as exchanges of an asset.
  • 2) Rule execution is very efficient. Where the distributed network must execute your validation rules, then validation requires all nodes to do all validation. Client-side validation only requires the systems that care about those rules to run them. Factom allows a Chain to define its rules in whatever language the designers choose, to run on whatever platform they choose, and to use any external data. None of these decisions on the part of one Application has any impact on another Application.
  • 3) Factom Servers have little knowledge about the Entries being recorded. We use a commitment scheme to limit knowledge, where the commitment to record an Entry is made prior to revealing what the Entry is. This makes Factom's role in recording Entries very simple, and makes individual server processes public. Factom servers accept information from the network of full nodes, and their decisions and behavior are in view. Failure to perform can be audited both from the network outside Factom, and within Factom. It is easy to independently verify that a Factom server is fulfilling its Entry-recording responsibility; Factom can't hide potentially errant behavior.
  • 4) Recording speeds can be very fast, since the number of checks made by the Factom servers are minimal.
  • 5) Proofs against any particular Chain in Factom do not require knowledge of any other Chains. Users then only need the sections of Factom they are using and can ignore the rest.
• At its heart, Factom is a decentralized way to collect, package, and secure data into the Bitcoin blockchain. Factom accomplishes this with a network of Authority servers. Authority Servers are the set of Federated Servers and Audit Servers which share responsibility for different aspects of the system. The Federated Servers actually acknowledge and order entries and transactions in Factom, and Audit Servers duplicate and audit the work done by the Federated Servers and are always ready to replace a Federated Server that might go offline.
• The design ensures decentralization. No single server is ever in control of the whole system, but only a part of the system. All servers verify and double check the work of all other servers. And no server is permanently in control of any part of the system; the responsibility for each part of Factom cycles among the Federated Servers each minute, and the role of being a Federated Server or an Audit Server shifts among the servers in the Authority Set (the set of all Authority Servers).
• The Federated servers take a very active role in running the protocol. The Federated servers each take responsibility for a subsection of the user Chains at the beginning of the creation of a Directory Block. The process works like this:
• • 1. All servers reset their process lists to empty.
  • 2. The user submits an Entry Payment using a public key associated with Entry Credits
  • 3. Based on the public key used to pay for the Entry, one of the servers accepts the payment.
  • 4. That server broadcasts the acceptance of the payment.
  • 5. The user sees the acceptance and submits the Entry.
  • 6. Based on the ChainID of the Entry, one of the servers adds the Entry to its process list, and adds the Entry to the appropriate Entry Block for that ChainID (creating one if this is the first Entry for that Entry Block).
  • 7. The server broadcasts an Entry confirmation, containing the process list index of the Entry, the hash of the Entry (linked to the payment), and the serial hash so far of the server's process list.
  • 8. All the other servers update their view of the server's process list, validate the list, and update their view of the Entry Block for that ChainID.
  • 9. As long as the user can validate the relevant process list holds their Entry, then they have a fair level of assurance it will be successfully entered into Factom.
  • 10. At the end of the minute, each server confirms the end of their section of the process list. The end of the minute is marked in the process list, and the responsibility for particular chains shifts around the authority set.
  • 11. At the end of the10th minute, a Directory Block is constructed from all the Entry Blocks defined by the process lists built by all the servers. So, each server has all Entry Blocks, all Directory Blocks, and all Entries.
  • 12. A deterministic method (that can be computed by all nodes in protocol) will shift responsibility for particular ChainIDs among the servers for the next round.
  • 13. At the completion of the Directory Block, the Merkle root of the Directory block is placed in a Bitcoin transaction and submitted to the Bitcoin network for eventual confirmation.
  • 14. Repeat. (Go back to 1)
• The Federated servers for their minute are constructing a process list for the Chains for which they are responsible, as well as constructing the Entry Blocks that will be used to create the Directory Block at the end of the10 minutes. The process list is important for broadcasting decisions made by a server to the rest of the network.
• The servers in the authority set are re-ranked on a regular, scheduled basis. The ranking is a function of support by the standing parties, who must create a profile Chain in Factom. The profile contains any number of signed public address Entries. The weight of a standing party's support is determined by various public addresses and entries in their profile. The function computing the weight of a standing party uses a combination of many factors. Such weights may be organized in categories to further distribute influence. Factors that determine an identity's weight include factors that can be measured from the protocol, and audited by the protocol. Examples of factors that might be used to calculate weight include:
• Weighted Number of Entry Credits purchased.
• Weighted Number of Entries used.
• Tokens “staked” to a profile Chain, and not moved or transferred.
• Tokens used to build infrastructure, support the protocol, provide services
• Providing guidance and facilitating the operation of the protocol.
• Support may be specified by the Standing parties at any time. At regular intervals, the support of all the servers in the Authority set will be evaluated, and the membership of the authority set adjusted. The same mechanism can be used to measure support in the protocol for decisions about the protocol.
• To maintain a position in the authority set, servers must continually demonstrate the ability to maintain their ability to monitor and keep up with the operation of the protocol. The Federated Servers do this by simply doing their job and syncing with the end of minute operations with all other Federated Servers. Performance in the protocol's ecosystem may also factor into decisions to support or not support an authority node. Audit servers may have to issue a heartbeat message, that can be monitored by the network. Other solutions are possible.
• Managing timeouts and monitoring heartbeats will be done according to the needs and load on the protocol.
Factom System Overview
• FIG. 3 illustrates the Factom protocol as a set of layered data structures, according to exemplary embodiments. Factom is constructed of a hierarchical set of blocks, with the highest being Directory Blocks. They constitute a micro-chain, consisting primarily of compact references. To keep the size small, each reference in the Directory Block is just a hash of the Entry Block plus its ChainID. These Entry Blocks have references which point to all the Entries with a particular ChainID which arrived during a time period. The Entry Block for a Chain ID is also part of a micro-chain. The bulk of the data in Factom is at the leaves, the Entries themselves. These hierarchical data structures are rendered unchangeable by Bitcoin's hashpower. They can be conceptualized as different layers. The layers and concepts in the Factom system are:
• 1) Directory Layer—Organizes the Merkle Roots of Entry Blocks
• 2) Entry Block Layer—Organizes references to Entries
• 3) Entries—Contains an Application's raw data or a hash of its private data
• 4) Chains—Grouping of Entries specific to an Application
Directory Layer: How the Directory Layer Organizes Merkle Roots
• The Directory layer is the first level of hierarchy in the Factom system. It defines which Entry ChainIDs have been updated during the time period covered by a Directory Block. (ChainIDs identify the user's Chain of Entries; the generation of the ChainID is discussed later.) It mainly consists of a list pairing a ChainID and the Merkle root of the Entry Block containing data for that ChainID.
• Each Entry Block referenced in the Directory Block takes up 64 bytes (two 32 byte hashes, the ChainID and the Merkle root of the Entry Block). A million such Entries would result in a set of Directory Blocks roughly 64 MB in size. If the average Entry Block had 5 Entries, 64 MB of Directory Blocks would provide the high level management of 5 million distinct Entries. Note that the exact implementation of Directory blocks my vary as we build for greater scale in the future.
• If an Application only has the Directory Blocks, it can find Entry Blocks it is interested in without downloading every Entry Block. An individual Application would only be interested in a small subset of ChainIDs being tracked by Factom. This greatly limits the amount of bandwidth an individual client would need to use with Factom as their system of record. For example, an Application monitoring real estate transfers could safely ignore video camera security logs.
• Factom servers collect Merkle roots of Entry Blocks and package them into a Directory Block. Directory Block the Merkle roots are recorded into the Bitcoin blockchain. This allows the most minimum expansion of the blockchain, and still allows the ledger to be secured by the Bitcoin hash power. The process of adding the Merkle root into the Bitcoin blockchain we referred to as “anchoring”. See the section “Appendix: Timestamping into Bitcoin” for further details.
• Data entered into Directory Blocks is the most expensive, from a bandwidth and storage perspective. All users of Factom wishing to find data in their Chains need the full set of Directory Blocks starting from when their Chain began.
• Activities that increase the Directory Block size include the creation and first update of individual Chains. These activities externalize costs of Applications attempting finer-grained organization.
• The Applications must be required to expend more Entry Credits than a simple Entry would necessitate to discourage bloating the Directory Blocks.
Entry Block Layer: How the Entry Block Layer Organizes Hashes and Data
• FIG. 4 illustrates entry blocks of the Factom protocol, according to exemplary embodiments. Entry Blocks are the second level of hierarchy in the system. Individual Applications will pay attention to various ChainIDs. Entry Blocks are the place where an Application looking for Entries can expand its search from a ChainID to discover all possibly relevant Entries.
• There is one Entry Block for each updated ChainID per Directory Block. The Entry Blocks contain hashes of individual Entries. The hashes of Entries both prove the existence of the data and give a key to find the Entries in a Distributed Hash Table (DHT) network. (See the below explanation of the “Factom Peer-to-Peer Network” for more detail.)
• The Entry Blocks encompass the full extent of possible Entries related to a ChainID. If an Entry is not referred to in an Entry Block, it can be assumed not to exist. This allows an Application to prove a negative, as described in the section Security and Proofs.
• The Entry Block intentionally does not contain the Entries themselves. This allows the Entry Blocks to be much smaller than if all the data was grouped together. Separating the Entries from the Entry Blocks also allows for easier auditing of auditors. An auditor can post Entries in a separate chain that approves or rejects Entries in a common chain. The audit can add reasons for rejection in its Entry. If an Application trusts the auditor, they can cross reference that the auditor has approved or rejected every Entry, without knowing what the Entry is. The Application would then only attempt to download the Entries which passed the audit. Multiple auditors could reference the same Entries, and the Entries would only exist once on the Distributed Hash Table (DHT). Entries are expected to be significantly larger than the mere 32 bytes a hash takes up. Lists of things to ignore do not have to have the full object being ignored for an Application to know to ignore it. The exact implementation of entry blocks may vary in the future in response to identified improvements possible in the protocol.
• An Entry detailing the specifics of a land transfer would be entered into a Chain where land transfers of that type are expected to be found. One or more auditors could then reference the hashes of land transfer in their own Chains, adding cryptographic signatures indicating a pass or fail. The land transfer document would only need to be stored once, and it would be referenced by multiple different Chains.
• FIG. 5 illustrates how entries are created, according to exemplary embodiments. Entries are constructed by users and submitted to Factom. By hashing or encoding information, the user can ensure the privacy of Entries. The Entries can instead be plain text if encoding or obscuring the data isn't necessary. By recording a hash of a document, Factom can provide basic proof of publication. Presenting the document at a later time allows one to create its hash, and compare it to the hash recorded in the past.
• There is lots of flexibility in the data that is accepted. It can be something short like a hyperlink. It could also be larger, but not too large, since fees limit the size of the data accepted. This is similar to Bitcoin. Large 100 kB+Bitcoin transactions are possible, but would need to pay a proportionately greater transaction fee. This size, while gigantic in Bitcoin, would be moderately sized for Factom. Since every Bitcoin full node needs the entire blockchain to fully validate, it needs to stay small. In Factom, only the highest level Directory Blocks are required to fully validate a Chain. If someone is not specifically interested in a Chain's data, they would not download it.
• Take a simple example of an uneditable Twitter-like system. A celebrity would craft an Entry as a piece of text. They would then sign it with a private key to show it came from them. Followers of the celebrity would find which Chain they publish in and would monitor it for updates. Any new signed Entries would be recognized by follower's Application software as a tweet. Others could tweet at the celebrity by adding Entries to the celebrity's Chain.
• FIG. 6 illustrates the complete Factom protocol and system, according to exemplary embodiments. Chains in Factom are sequences of Entries that reflect the events relevant to an Application. These sequences are at the heart of Bitcoin 2.0. Chains document these event sequences and provide an audit trail recording that an event sequence occurred. With the addition of cryptographic signatures, those events would be proof they originated from a known source.
• Chains are logical interpretations of data placed inside Directory Blocks and Entry Blocks. The Directory Blocks indicate which Chains are updated, and the Entry Blocks indicate which Entries have been added to the Chain. This is somewhat analogous to how Bitcoin full clients maintain a local idea of the UTXO (Unspent Transaction Output) set. The UTXO set is not (currently) in the blockchain itself, but is interpreted by the full client.
The Factom Peer-to-Peer Network
• Factom will have a peer-to-peer (P2P) network which accomplishes two goals: communication and data preservation.
Factom Peer-to-Peer Communications
• Factom will have a P2P network very similar to Bitcoin's. It will consist of full nodes which have all the Factom data. The full nodes create a gossip network which will flood fill valid data throughout the network. The Authority servers would be full nodes, but not all full nodes are Authority servers. This is very much like Bitcoin, where miners are full nodes, but not all full nodes are miners. This will limit the ability to DDOS the Authority servers individually. They can connect anywhere inside the network to acquire the data needed to build the data structures.
• As the servers are coming to consensus and disseminate their signed data, they would publish the data over the P2P network. The P2P flood filling also limits the ability of Authority servers to censor based on IP addresses, since valid traffic is mixed together by the nodes they connect to. It also helps to prevent censorship, since all servers can see the Entries which should be included in the Entry Blocks. Outside organizations campaigning to become Authority servers have an incentive to bring bad behavior to light, so they can gain support and move up into the set of Authority Servers.
Data Preservation and Dissemination
• Factom data structures (Directory Blocks, Entry Blocks, Entries) are needed for Factom to be useful. They are public and will be preserved in two places. The Authority Servers need to maintain this data to make correct decisions about adding new Entries. Since they have this data, they can provide it as a service, as part of being a full node. As the protocol grows the protocol will be able to support partial nodes, which share only part of the Factom dataset. The partial nodes could share only the data which is relevant to their specific application. Peer discovery for the partial nodes may be handled by any sort of directory service, such as a Distributed Hash Table (DHT).
• FIG. 7 illustrates a read operation, according to exemplary embodiments. This setup allows for efficient peer distribution of data even if the entire Factom dataset grows to unwieldy sizes. The Directory Service also allows the data to be preserved independent of any Authority servers or full nodes. Even if all the full nodes were removed from the network, the data could still be shared by a more numerous set of parties interested in specific subsets of the data.
• FIG. 8 further illustrates the Chain ID, according to exemplary embodiments. Factom groups all Entries under a ChainID. The ChainID is computed from a Chain Name. The ChainID is a hash of the Chain Name. The Chain Name is a byte array arbitrarily long in length. See figure below. Since the conversion from Chain Name to ChainID is a hash operation, it is a simple process. Deriving a Chain Name from a ChainID is not simple, so a lookup table would be needed.
• The user may provide a Chain Name, or the Chain Name may be auto-generated. Regardless, that the ChainID can be shown to be a hash of something. This prevents unhashed data from being a ChainID, which is stored all the way up to the Directory Blocks. This convention eliminates insertion of obscene plaintext in the block structure.
• The Chain Name is fairly arbitrary. It could be a random number, a string of text, or a public key. An individual Application could derive meaning from different Chain Names.
• One possible convention would be to use human readable text for the Chain Name. This would allow for the structuring of Chains in a logical hierarchy, even though Chains are not hierarchical by nature. Users can even use the same naming conventions, but by making simple modifications, ensure that there are no accidental intersections between their Chains and other Chains. Consider the following path:
MyFavoriteApp/bin,
• where the slash is a convention for another level of hierarchy. The slash separating ASCII strings “MyFavoriteApp” and “bin” represents transitioning to a deeper level. These two strings must be converted to bytes, and there are many options for doing so. The strings could be encoded in UTF-16, UTF-32, ASCII, or even something like IBM's EPCDIC. Each of these encodings would result in entirely different ChainIDs for the same string, since the computation of the ChainID is done from the bytes. Furthermore, the application could utilize a Globally Unique IDentifier (GUID) number as the first byte array in their naming convention. This would eliminate overlap of one Application's ChainID “space” with another, at the expense of just a few more bytes in the Chain creation.
Using Factoids to Purchase Entry Credits
• Factoids are the main internal scarcity token used to moderate and reward the system actors. The right to put Entries into Factom is represented by Entry Credits. Factom separates the two value-holding mechanisms, as they serve different purposes. Factoids can be converted into Entry Credits, but not vice versa.
• Factoids are implemented in much the same way Bitcoin is implemented, allowing multiple inputs, multiple outputs, etc. where each input requires the proper signature for the transaction to be valid. Other sorts of validation including multisig is possible. Factoid transactions are managed on a special Factoid Chain. This Factoid Chain is handled more restrictively than other Chains. Entries in the Factoid Chain must be valid Factoid transactions, or the Factom Servers will reject the Entries.
• Factoids are included into the protocol to completely decentralize Factom, and to reduce bloat and spam in both Factom and Bitcoin. Factoids can be converted to Entry Credits in the protocol, and paid out to Factom servers from the protocol. Factoids budgeted but not paid out can remain in a “grant pool”. These tokens can be issued to support and develop the protocol from the protocol.
• Factoids also help to bind consensus. If consensus is lost, then the Factoids will fall in value, incentivizing the support of the protocol.
• The conversion of a Factoid to Entry Credits will be done via a special purchase transaction on the Factoid Chain. This purchase transaction will include:
• An Output directing a Factoid amount to be converted
• The public key that is to receive the Entry Credits
• The Entry Credits, once purchased, cannot be transferred to another public key. They can only be used to pay for Entries. This greatly reduces their value to thieves, since they cannot be resold. Entry Credit private keys can be held in low security areas with minimal risk.
Using Entry Credits to Write Entries
• Adding Entries into Factom requires giving up a scarce resource. That resource is Entry Credits, which are derived from Factoids. Adding Entries to Factom is a two step process. First the Entry is paid for (committed). The payment accomplishes two things. It decrements the Entry Credits associated with a user's public key. In the same operation, the hash of the Entry is specified. After the Entry is paid for, the server will wait for the unhashed Entry and include it once seen (revealed).
• 1. Pay for Entry
• • Decrement Entry Credits owned by a user
  • User specifies hash of Entry in payment
• 2. Insert Entry
• • User publishes Entry for inclusion in Entry Block
• There are many benefits of this two step process. One benefit is to separate the payment overhead from the recorded data. Future users will not be forced to download the data generated by payment minutia. They only need to download the minimum data to validate their system. It allows users to safely and easily ignore the payment information.
• Another benefit is censorship resistance. By committing to accept an Entry before knowing the content makes censorship by the Factom servers obvious. Adam Back has advocated for a similar mechanism for Bitcoin in a post titled “Blind Symmetric Commitment for Stronger Byzantine Voting Resilience” (https://bitcointalk.org/index.php?topic=206303.0). If a user or Audit server can show an Entry which has been properly been paid for, but none of the Federated servers are accepting it, then the censorship is provable.
• The transactions deducting Entry Credits will be recorded in a special Chain, similar to the Factoid Chain. The Federated servers will only fill the Chain with valid Entry Credit transactions.
• Setting the Cost of Entries with a Central Server Oracle
• The conversion rate of Factoids to Entry Credits will be determined by first choosing a target real world value for an Entry Credit. This target will be determined by a distributed and autonomous process. At minimum it will be agreed upon by some process driven by the Authority Set. Other parties might be involved through various auditable processes in Factom to further decentralize the decision.
• Once a target real world target price of an Entry Credit has been chosen, an Oracle is required to record into Factom the conversion value between Factoids and that EC price. That specification and implementation will also go through a decentralized decision process. The actual implementation of the target price, oracle implementation, and exchange rate adjustment can vary widely, but will be optimized for decentralization, security, and regulatory compliance.
• Note that fee calculations and rates are subject to change, and don't materially impact the utility of the Factom protocol.
• Using Factom without Factoids
• Many users of Factom may not want a wallet, and will not want to hold any cryptocurrency asset. But they will want to create their Chains (ledgers) and add their Entries. Factom's two step recording process allows for the separation of Factoids, Factom's tradable token, from the opportunity to post Entries to Factom, represented by Entry Credits. Servers and other recipients of Factom Tokens can sell Entry Credits to customers for payment via Bitcoin, conventional credit card payments, etc. The user would provide a public key to hold the Entry Credits. The seller would convert the appropriate amount of Factoids to Entry Credits and assign those rights to the user's public key. Users could thus buy Entries Credits for Factom without ever owning the Factoids that drive the Factom servers.
• From a regulation point of view, this is powerful. The servers earn Factoids from the protocol. The only parties to that transaction are the server and the protocol. Then the server sells Entry Credits to users, who eventually return Factoids to the rest of the system. Entry Credits are non transferable, so the user cannot assign them to another user's public key, and selling private keys isn't practical or useful. In neither transaction is a tradable token (the Factoid) transferred between two parties.
• Factom is a distributed, autonomous layer residing on top of the Bitcoin blockchain. The goal of Factom is to provide the power of Bitcoin's blockchain to a nearly unlimited range of Applications and uses. Further, Factom is architected such that its users do not need any cryptocurrency whatsoever.
• A distributed, immutable ledger is the radical, foundational, and unprecedented technology represented by the Bitcoin blockchain. The dream of many is to extend the honesty inherent to an immutable ledger validated by math to chaotic, real-world interactions. By allowing the construction of unbounded ledgers backed by the blockchain, Factom extends the benefits of the blockchain to the real world.
• FIGS. 9-21 are simplified illustrations of adigital contract20 in ablockchain environment22, according to exemplary embodiments. Thedigital contract20 is sometimes referred to as a self-executing or “smart” contract between parties to a transaction. Thedigital contract20 may be executable code that runs on ablockchain24. Theblockchain24 has one ormore blocks26 of data. A conventional smart contract facilitates, executes, and/or enforces the terms of an agreement. Whatever the terms, thedigital contract20 may automatically execute the terms once predetermined logical rules, conditions, or code is satisfied. Thedigital contract20 may thus be expressed in a programming language. Smart contracts are generally known, so this disclosure will not dwell on the known aspects.
• Here, though, theblockchain24 need only reference thedigital contract20. That is, the actual programming language defining thedigital contract20 need not be included within or attached to theblockchain24. Instead, theblockchain24 need only include or specify acontract identifier28 and perhaps one or morecontractual parameters30. Thecontract identifier28 is any digital identifying information that uniquely identifies or references thedigital contract20. Similarly, thecontractual parameters30 may digitally identify the parties to thedigital contract20, their respective performance obligations and terms, and even consideration. So, instead of theblockchain24 carrying or conveying the actual code representing thedigital contract20, exemplary embodiments need only specify thecontract identifier28 and perhaps thecontractual parameters30. Theblocks26 of data within theblockchain24 are thus not burdened with the programming code that is required to execute thedigital contract20. Theblockchain24 need only include or specify thecontract identifier28 and/or the contractual parameters30 (or their respective hash values), thus greatly simplifying theblockchain24 and reducing its size (in bytes) and processing requirements.
• FIG. 10 further illustrates theblockchain24. Here anyentity32 may generate theblockchain24. While exemplary embodiments may be applied to anyentity32, most readers are thought familiar with financial services. That is, suppose theentity32 is a bank, lender, or other financial institution34 (such as PIMCO®, CITI®, or BANK OF AMERICA®). As the reader likely understands, thefinancial institution34 creates a massive amount of banking records, transaction records, mortgage instruments, and otherprivate data36. Thefinancial institution34 thus has afinancial server38 executing asoftware application40 that encrypts itsprivate data36. While thesoftware application40 may use any encryption scheme,FIG. 2 illustrates theprivate blockchain24. That is, thesoftware application40 causes thefinancial server38 to cryptographically hash theprivate data36 and to integrate the resulting hash value(s) into theblock26 of data within theprivate blockchain24. Moreover, because theprivate data36 may represent contractual obligations between parties, thesoftware application40 may further cause theblockchain24 to include thecontract identifier28 and thecontractual parameters30. Thecontract identifier28 and thecontractual parameters30 may be encoded as data or information contained within theblock26 of data, or thecontract identifier28 and thecontractual parameters30 may be data or information that is separate from theblock26 of data (such as informational content in metadata or in a packet header/body). Regardless, theblockchain24 need not include the programming code representing thedigital contract20. Theblockchain24 need only specify thecontract identifier28 and/or thecontractual parameters30.
• FIG. 11 illustrates acontract server42. Thecontract server42 may be responsible for executing thedigital contract20 referenced by thecontract identifier28 and/or thecontractual parameters30. For example, after the financial server38 (executing the software application40) generates theblock26 of data within theblockchain24, thefinancial server38 may send theblockchain24 to the network address (e.g., Internet protocol address) associated with thecontract server42. When thecontract server42 receives theblockchain24, thecontract server42 inspects theblockchain24 to identify thecontract identifier28 and/or thecontractual parameters30. Once thecontract identifier28 is determined, thecontract server42 may then consult anelectronic database44 of contracts. Thedatabase44 of contracts has entries that map or relate thecontract identifier28 to its correspondingdigital contract20. Thedatabase44 of contracts, in other words, may identify acomputer file46 that contains the programming language representing thedigital contract20 identified by thecontract identifier28. So, once thedigital contract20 is determined, thecontract server42 may retrieve and locally execute thecomputer file46, perhaps based on parameters defined or described by the contractual parameters30 (such as party names, parameters associated with their respective performance obligations and terms, and consideration). Again, then, theblockchain24 need only reference the digital contract20 (using thecontract identifier28 and/or the contractual parameters30). The actual execution of thedigital contract20 may be offloaded or outsourced to thecontract server42.
• FIG. 12 also illustrates thecontract server42. Here, though, thecontract server42 may only manage the execution of thedigital contract20 referenced by thecontract identifier28 and/or thecontractual parameters30. That is, thecontract server42 may outsource the execution of thedigital contract20 to a vendor, a supplier, or a subcontractor process. Again, when thecontract server42 receives theblockchain24, thecontract server42 inspects theblockchain24 to identify thecontract identifier28 and/or thecontractual parameters30. Thecontract server42 may then consult thedatabase44 of contracts. Here, though, thedatabase44 of contracts has entries that map or relate thecontract identifier28 to anetwork resource50 that processes and/or executes thedigital contract20 as a service (perhaps as a software-as-a-service or “SAAS”). Thenetwork resource50 may thus be a remote server, a virtual machine, a web page or web server, a client device/machine, or other resource that executes thedigital contract20. Once thenetwork resource50 is determined, thecontract server42 may retrieve and send thecontractual parameters30 to thenetwork resource50 for execution. The network resource50 (perhaps operated on behalf of a third party) applies the parameters defined or described by thecontractual parameters30 to the programming code representing thedigital contract20.
• Exemplary embodiments thus only need to identify thedigital contract20. Thecontract identifier28 and thecontractual parameters30 need only be informational content in theprivate blockchain24. Thecontract identifier28 is any digital identifying information that uniquely identifies or references thedigital contract20. Thecontract identifier28 may be an alphanumeric combination that uniquely identifies a vendor and/or version of thedigital contract20 and/or a processor or executioner of thedigital contract20. Thecontract identifier28 may be expressed as a unique hash value that is included within, or specified by, theprivate blockchain24. Similarly, thecontractual parameters30 may identify the parties to thedigital contract20, their respective performance obligations and terms, and consideration.
• FIG. 13 illustrates consideration. When thedigital contract20 is executed, the parties to thedigital contract20 may be compensated (perhaps according to thecontractual parameters30 describing consideration). Moreover, thecontract server42 and/or thenetwork resource50 may also be compensated. While there are many compensation schemes, this disclosure mostly explains crypto-compensation. That is, when thedigital contract20 successfully executes, perhaps the parties exchange, trade, or transfer cryptographic currencies. Suppose, for example, that thefinancial institution34 creates itsown cryptographic coinage60 in theblockchain environment22. Theentity32, in other words, may establish entity-specificelectronic tokens62 to access and/or to use theblockchain environment22. Because theprivate blockchain24 represents hashes of the financial institution'sprivate data36, theprivate blockchain24 may be considered a private resource or property of thefinancial institution34. That is, theprivate blockchain24 is controlled by, or affiliated with, thefinancial institution34, so thefinancial institution34 may control who adds and/or writes to theprivate blockchain24 and who reads, accesses, or receives theprivate blockchain24.
• The entity-specific tokens62 may thus be control mechanisms. While the entity-specific tokens62 may have any functional scheme,FIG. 5 illustrates aprivate credit token64 and a privatetradeable token66. The entity'scredit token64, for example, may be acquired and then spent or burned when accessing the financial institution'sprivate blockchain24. The entity'scredit token64, in other words, represents any credit-based entry system associated with the financial institution'sprivate blockchain24. Thetradeable token66, on the other hand, may be generated for transfer among others. Theentity32 generates thetradeable token66 to be traded and/or spent. Thetradeable token66, in other words, may be considered as the entity's specific, private currency to be used as theentity32 governs.
• Exemplary embodiments may thus trade or exchange crypto-compensation. That is, when thedigital contract20 successfully executes, perhaps the parties exchange, trade, or transfer thecredit token64 and/or thetradeable token66. When any party, or all the parties, perform their assigned role in the transaction, value is given via thecredit token64 and/or thetradeable token66. Similarly, thecontract server42 and/or thenetwork resource50 may also be compensated via thecredit token64 and/or thetradeable token66, perhaps as a “mining” fee for executing thedigital contract20.
• Thedigital contract20 is thus a computer program or code that verifies and/or enforces negotiation and/or performance of a contract between parties. One fundamental purpose of so-called smart contracts is to integrate the practice of contract law and related business practices with electronic commerce protocols between parties or devices via the Internet. Smart contracts may leverage a user interface that provides one or more parties or administrators access, which may be restricted at varying levels for different people, to the terms and logic of the contract. Smart contracts typically include logic that emulates contractual clauses that are partially or fully self-executing and/or self-enforcing. Examples of smart contracts are digital rights management (DRM) used for protecting copyrighted works, financial cryptography schemes for financial contracts, admission control schemes, token bucket algorithms, other quality of service mechanisms for assistance in facilitating network service level agreements, person-to-person network mechanisms for ensuring fair contributions of users, and others. Smart contract infrastructure can be implemented by replicated asset registries and contract execution using cryptographic hash chains and Byzantine fault tolerant replication. For example, each node in a peer-to-peer network or blockchain distributed network may act as a title registry and escrow, thereby executing changes of ownership and implementing sets of predetermined rules that govern transactions on the network. Each node may also check the work of other nodes and in some cases, as noted above, function as miners or validators.
• FIG. 14 further illustrates thecontract server42. When thecontract server42 receives theblockchain24, here thecontract server42 may generatedata records70 in ablockchain data layer72, as later paragraphs will explain. Thecontract server42 may thus be termed or called adata layer server74. Moreover, theblockchain data layer72 may also add another layer of cryptographic hashing to generate apublic blockchain76. Theblockchain data layer72 acts as avalidation service78 that validates thedigital contract20 was executed. Moreover, theblockchain data layer72 may generate acryptographic proof80. Thepublic blockchain76 thus publishes thecryptographic proof80 as apublic ledger82 that establishes chains of blocks of immutable evidence.
• FIGS. 15-16 illustrate examples of the entity-specific tokens62. Suppose that a third-party90 wishes to receive, read, write to, or otherwise access the financial institution'sprivate blockchain24 and/or thedigital contract20. AsFIG. 15 illustrates, exemplary embodiments may require that the third-party90 spend or burn one or more of thecredit tokens64. Thecredit token64 may thus control access to the financial institution'sprivate blockchain24 and/or thedigital contract20. The inventor envisions that vendors, service providers, individual users, and other third-parties60 may wish to access the hash values of theprivate data36 contained within the financial institution'sprivate blockchain24. Moreover, the third party may want to access, inspect, execute, or verify thedigital contract20. Thefinancial institution34 may thus require that the third-party90 redeem the entity's credit token(s)50 before granting read, write, or access permission to thedigital contract20. Thefinancial institution34 may additionally or alternatively require redemption of the entity's credit token(s)64 for using protocols, rules, and application programming interfaces (“APIs”) associated with theprivate blockchain24 and/or thedigital contract20. Thefinancial institution34 may thus establish or issue itsown credit tokens64 and even govern theirusage restrictions92 andvalue94, as later paragraphs will explain.
• FIG. 16 illustrates thetradeable token66. Thefinancial institution34 may establish thetradeable token66 and also govern itsusage restrictions92 andvalue94. Thetradeable token66, in other words, is a cryptocurrency or “coin.” Again, while exemplary embodiments may utilize any functional scheme, thetradeable token66 may be earned. That is, anyone (such as the third party90) may earn thetradeable token66 according to theusage restrictions92. For example, suppose thedata layer server74 earns the entity's tradeable token(s)52 in exchange for processing and/or managing an execution of thedigital contract20. Thedata layer server74 may additionally or alternatively earn the entity's tradeable token(s)52 in exchange for thevalidation service78. That is, a provider of thevalidation service78 is paid, or earns, the entity's tradeable token(s)52 for processing or executing thedigital contract20 and/or for cryptographically hashing theproof80 of thedigital contract20. The provider of thevalidation service78 may also be paid in the entity's tradeable token(s)52 for publishing theproof80. Thetradeable token66 may thus be transferred as currency according to theusage restrictions92 and itsvalue94.
• FIG. 17 illustrates transaction records100. Whenever the entity-specific tokens62 are created, owned, or transferred, thetransaction record100 may be generated. Thetransaction record100 may then be documented in theblockchain environment22. For example, the entity-specific tokens62 may be addressable. That is, thecredit token64 and thetradeable token66 may be uniquely associated with a common,single cryptographic address102. Thecryptographic address102 may represent an owner or holder (e.g., theentity32 or the third-party90). When the entity-specific tokens62 are created, generated, or assigned, the entity-specific tokens62 may be assigned or associated with thecryptographic address102. Thecryptographic address102 may then be received by, and propagated within, theblockchain data layer72 to identify the corresponding data records70. Theblockchain data layer72 may even hash thecryptographic address102 as thecryptographic proof80 of the transaction records100. Exemplary embodiments thus publicly document the transaction records100 involving the entity-specific tokens62, based on thesingle cryptographic address102. In simple words, theblockchain data layer72 publishes ownership and transferproofs80 of thecredit token64 and thetradeable token66 based on the transaction records100 associated with thesingle cryptographic address102.
• The transaction records100 may also document thedigital contract20. Whenever thedigital contract20 is specified, generated, processed, or even executed, thetransaction record100 may be generated. Thetransaction record100 may then be documented in theblockchain environment22. For example, the entity-specific tokens62 may be earned as payment according to the executable terms of thedigital contract20. The entity-specific tokens62 may additionally or alternatively be earned or awarded for processing or executing a portion of, or entirely, thedigital contract20. The entity-specific tokens62 may thus be uniquely associated with a party to thedigital contract20 and/or with a service provider/processor of thedigital contract20. Thetransaction record100 may document the parties to thedigital contract20, a transactional description describing a transaction governed by thedigital contract20, and any financial or performance terms. Thetransaction record100 may thus document an offer, an acceptance, a consideration, and terms. For simplicity, then, thesingle cryptographic address102 may represent a party to thedigital contract20 and/or with a service provider/processor of thedigital contract20. Regardless, when the entity-specific tokens62 are created, generated, or assigned, the entity-specific tokens62 may be received by, and propagated within, theblockchain data layer72 to identify the corresponding data records70. Theblockchain data layer72 may thus publish theproofs80 of thedigital contract20 and any entity-specific tokens62 paid or exchanged, according to the transaction records100.
• FIG. 18 illustrates a fillingstation110 in theblockchain environment22. Because thetokens62 may be consumed by users (such as during or after any processing or execution of the digital contract20), the fillingstation110 allows thethird party90 to replenish or fill anaccount112. Recall that the third-party entity32 may be required to spend thetokens62 to access the financial institution'sprivate blockchain24 and/or thedigital contract20. Moreover, thetokens62 may also be earned or transferred according to the terms of thedigital contract20. Theaccount112 may thus be established, and theaccount112 maintains a monetary ornumerical balance114 of thetokens62. As thetokens62 are spent, traded, or redeemed, theaccount112 may need filling to continue using or accessing theblockchain24 and/or thedigital contract20.
• The fillingstation110 may access both the transaction records100 and theblockchain data layer72. Because theblockchain data layer72 may document the data records70 using thesingle cryptographic address102, thesingle cryptographic address102 may serve as a common reference or query parameter with the entity's transaction records100. The fillingstation110, in other words, may use thesingle cryptographic address102 to identify the transaction records100 that correspond to theblockchain data layer72. The fillingstation110 may thus present a transaction summary of theaccount112 and thebalance114. Becauseblockchain data layer72 may track and/or prove the transaction records100, exemplary embodiments may search theblockchain data layer72 for thesingle cryptographic address102. That is, the fillingstation110 may query theblockchain data layer72 for thesingle cryptographic address102, and theblockchain data layer72 may identify the transaction records100 that match thesingle cryptographic address102. Similarly, exemplary embodiments may query theblockchain data layer72 for thecontract identifier28 and/or thecontractual parameters30, and theblockchain data layer72 may identify the transaction records100 that match thecontract identifier28 and/or thecontractual parameters30. The fillingstation110 may then process the transaction records100 to provide the transaction summary of theaccount112, thebalance114, and any other transactional data. The fillingstation110 may also allow the user to replenish an amount or value of thetokens62, thus allowing the user to continue exchanging thetokens62 for access to theprivate blockchain24, theblockchain data layer72, and/or thedigital contract20. The fillingstation110 may thus be an access mechanism to theblockchain data layer72.
• FIG. 19 further illustrates the fillingstation110. Here theblockchain data layer72 may have itsown cryptocoinage120. That is, a provider of theblockchain data layer72 may establish itscryptocoinage120 for accessing and/or using thevalidation service78. Thecryptocoinage120 may thus include a credit token and a tradeable token (not shown for simplicity). The credit token may be required to enter or access theblockchain data layer72 to receive thevalidation service78, and the tradeable token may be earned for participating in thevalidation service78. Regardless, the fillingstation110 may use thesingle cryptographic address102. Thethird party90 may use thesingle cryptographic address102 to access the entity'scryptocoinage60 and the blockchain data layer'scryptocoinage120. Exemplary embodiments may thus identify and track the transaction records100 and the blockchain data layer'scryptocoinage120 using the same,single cryptographic address102.
• Exemplary embodiments thus present elegant solutions. Anyentity32 may create its ownprivate blockchain24 and offer or present thedigital contract20 for self-execution. Theentity32 may then establish or create thetokens62 for using, accessing, or processing the entity'sprivate blockchain24 and/or thedigital contract20. Thetokens62 may have thevalue94, thus fostering a market for entity-specific tradeable assets in theblockchain environment22. Thetradable value94 of thetokens62 may thus drive demand to use thedigital contracts20. Exemplary embodiments may thus provide a two-token system that isolates any use of the entity'sprivate blockchain24 from the entity'stradeable token66. Moreover, thecredit token64 may be associated with the third party90 (perhaps via the single cryptographic address102), thus allowing thethird party90 to retrieve theaccount balance114 from the fillingstation110 and sign entries or other transactions. Moreover, thethird party90 may also use thesingle cryptographic address102 to access theblockchain data layer72 via the fillingstation110. The fillingstation110 is a single resource or destination (such as a secure website) for managing a user'scryptographic coinage60 and defining payments according to thedigital contract20.
• FIG. 20 expands the entity concept. Here multiple,different entities32a-dprovide theirrespective software applications40a-dthat encrypt their respectiveprivate data36a-das their individual,private blockchains24a-d. While exemplary embodiments may be applied to any number of industries or services,FIG. 20 illustrates a simple example of four (4)different entities32a-d.First entity32a, for example, again represents the bank, lender, or otherfinancial institution34 that encrypts itsprivate data36aas itsprivate blockchain24a. Second entity32brepresents any retailer122 (such as HOME DEPOT®, KOHL'S®, or WALMART®) that encrypts itsprivate data36bas itsprivate blockchain24b. Third entity32crepresents aweb site124 offering a service126 (such as AMAZON®, NETFLIX®, or GOOGLE®) that encrypts itsprivate data36cas theprivate blockchain24c. Fourth entity32drepresents an automotive or other manufacturer or supplier128 (such as FORD®, TOYOTA®, or DELPHI®) that encrypts itsprivate data36das theprivate blockchain24d. Theentities32a-dthus use theirrespective software applications40a-dto provide afirst layer130 of cryptographic hashing. Theentities32a-dmay also use theirrespective software applications40a-dto issue their own private and entity-specific cryptocoinage60a-d. Eachentity32a-dmay then send their respectiveprivate blockchains24a-dto theblockchain data layer72, and theblockchain data layer72 may add asecond layer132 of cryptographic hashing. Theblockchain data layer72 thus generates thepublic blockchain76 as a public resource or utility for record keeping. Anyentity32 that subscribes to the blockchain data layer72 (such as by acquiring and/or spending the cryptocoinage120) may thus access, read, and/or store theproofs80 of itsprivate data36 to thepublic blockchain76. Theblockchain data layer72, in other words, acts as thepublic ledger82 that establishes chain of blocks of immutable evidence.
• AsFIG. 20 also illustrates, eachentity32a-dmay establish its ownprivate cryptocoinage60a-d. Each entity'sprivate software application40a-dmay create and/or issue itscryptocoinage60a-d(such as respective entity-specific tokens62 above explained). Eachentity32a-dmay also establish its own usage restrictions and value (illustrated asreference numerals92 and94 inFIGS. 15-16) according to rules governing ownership, trade, and other policies. Eachentity32a-dmay generate and sends itsrespective transaction records100a-dwhich reference each entity'ssingle cryptographic address102a-dto theblockchain data layer72 for documentation.
• AsFIG. 20 further illustrates, eachentity32a-dmay also specify their respectivedigital contract20a-d. When any of theprivate blockchains24a-dis received, theblockchain data layer72 may coordinate execution of anydigital contract20a-d. Theblockchain data layer72, for example, may inspect anyprivate blockchain24a-dand identify any information associated with thedigital contract20a-d. Theblockchain data layer72 may then execute thedigital contract20a-d, and/or theblockchain data layer72 may identify a service provider that executes thedigital contract20a-d. Theblockchain data layer72, in other words, may manage the execution of thedigital contracts20a-daccording to a subcontractor relationship. A provider of theblockchain data layer72 may then be compensated via any entity'scryptocoinage60a-dand/or the blockchain data layer'scryptocoinage120.
• AsFIG. 21 illustrates, the fillingstation110 may be agnostic. Any user (such as theentity32a-dor the third party90) may authenticate to the fillingstation110. Once authenticated, the user need only enter or provide the correctsingle cryptographic address102a-dto access the entity'sprivate cryptocoinage60a-d, the blockchain data layer'scryptocoinage120, and/or the entity'sdigital contract20a-d. Thesingle cryptographic address102a-d, in other words, allows the user to access heraccount112 and balance114 for the entity'sprivate cryptocoinage60a-d, the blockchain data layer'scryptocoinage120, and/or the entity'sdigital contract20a-d. The user may thus easily conduct transactions between the entity'sprivate cryptocoinage60a-dand the blockchain data layer'scryptocoinage120. Theentity32a-d, for example, may fuel or replenish its supply of the blockchain data layer'scryptocoinage120, perhaps by redeeming or exchanging the entity'sprivate cryptocoinage60a-d(perhaps according to an exchange rate or other value). Similarly, the provider of theblockchain data layer72 may fuel or replenish its supply of the entity'sprivate cryptocoinage60a-dby purchasing or exchanging the blockchain data layer'scryptocoinage120. The provider of theblockchain data layer72 may also earn the entity'sprivate cryptocoinage60a-dby processing any portion of, or by executing, the entity'sdigital contract20a-d. Moreover, the respectiveprivate blockchains24a-dand theblockchain data layer72 would contain the data records70 confirming the processing and/or execution of thedigital contract20a-d, so thetransaction records100a-dthus propagate into theblockchain data layer72 for public disclosure via thepublic blockchain76. Any user that successfully authenticates to the fillingstation110 may access a full accounting of his or herdigital cryptocoinages60a-dand/or120 and anydigital contracts20, perhaps according to the respectivesingle cryptographic address102a-d. The user may thus buy, sell, trade, and/or redeem any entity-specific cryptocoinages20a-dand/or90, all by accessing the fillingstation110. The user may buy or sell any entity's coins or replenish credits, all by accessing the fillingstation110. The user may also track performance or obligations defined by thedigital contracts20a-dand any payments or consideration received or paid.
• Exemplary embodiments thus present another elegant solution. The fillingstation110 is another service offered by theblockchain data layer72. Because all the transaction records100 in theblockchain data layer72 are identifiable (perhaps via the single cryptographic address102), the fillingstation110 can present the summary of the user's credit tokens and tradeable tokens. The fillingstation110 may thus provide a single or universal electronic wallet for all of a user's digital coinage and credits, regardless of the issuingentity32a-d. The user may thus only perform a single authentication to theblockchain data layer72 and access all her cryptofunds.
• FIGS. 22-24 are more detailed illustrations of an operating environment, according to exemplary embodiments.FIG. 22 illustrates anentity server140 communicating with thedata layer server74 via acommunications network142. Theentity server140 operates on behalf of theentity32 and generates the entity's private blockchain24 (such as thefinancial server38 explained with reference toFIGS. 10-19). Theentity server140, in other words, has a processor144 (e.g., “μP”), application specific integrated circuit (ASIC), or other component that executes the entity'ssoftware application40 stored in alocal memory device146. Theentity server140 has a network interface to thecommunications network142, thus allowing two-way, bidirectional communication with thedata layer server74. The entity'ssoftware application40 includes instructions, code, and/or programs that cause theentity server140 to perform operations, such as calling, invoking, and/or applying an electronic representation of ahashing algorithm148 to the entity'sprivate data36. Thehashing algorithm148 thus generates one or more hash values150, which are incorporated into the entity'sprivate blockchain24. The entity'ssoftware application40 then instructs theentity server140 to send theprivate blockchain24 via thecommunications network142 to a network address (e.g., Internet protocol address) associated with thedata layer server74.
• Thedigital contract20 may also be identified. The entity'ssoftware application40 may also instruct theentity server140 to specify thedigital contract20 as informational content in theprivate blockchain24. For example, thedigital contract20 may be identified by thecontract identifier28 andcontractual parameters30. Thecontract identifier28 is any digital identifying information that uniquely identifies or references thedigital contract20. Thecontract identifier28 may be an alphanumeric combination that uniquely identifies a vendor and/or version of thedigital contract20 and/or a processor or executioner of thedigital contract20. Thecontract identifier28 may also be one of the unique hash values150 (perhaps generated by the hashing algorithm148) that is included within, or specified by, theprivate blockchain24. Similarly, thecontractual parameters30 may identify the parties to thedigital contract20, their respective performance obligations and terms, and consideration.
• FIG. 23 illustrates theblockchain data layer72. Thedata layer server74 has a processor152 (e.g., “μP”), application specific integrated circuit (ASIC), or other component that executes adata layer application154 stored in alocal memory device156. Thedata layer server74 has a network interface to thecommunications network142. Thedata layer application154 includes instructions, code, and/or programs that cause thedata layer server74 to perform operations, such as receiving the entity'sprivate blockchain24, thedigital contract20, thecontract identifier28, and/or thecontractual parameters30. Thedata layer application154 then causes thedata layer server74 to generate theblockchain data layer72. Thedata layer application154 may optionally call, invoke, and/or apply thehashing algorithm148 to the data records70 contained within theblockchain data layer72. Thedata layer application154 may also generate thepublic blockchain76. Thedata layer application154 may thus generate thepublic ledger82 that publishes, records, or documents thedigital contract20, thecontract identifier28, and/or thecontractual parameters30. Indeed, if thedata layer application154 processes and/or manages thedigital contract20, the data records70 may document any processing or execution, and thedata layer application154 may optionally apply thehashing algorithm148 to the data records70 to generate thecryptographic proof80 of thedigital contract20.
• FIG. 24 illustrates additional publication mechanisms. Once theblockchain data layer72 is generated, theblockchain data layer72 may be published in a decentralized manner to any destination. Thedata layer server74, for example, may generate and distribute the public blockchain76 (via thecommunications network142 illustrated inFIGS. 22-23) to one or more federated servers160. While there may be many federated servers160, for simplicityFIG. 24 only illustrates two (2)federated servers160aand160b. Thefederated servers160aand160bprovide a service and, in return, they are compensated according to a compensation or services agreement or scheme.
• Exemplary embodiments include still more publication mechanisms. For example, thecryptographic proof80 and/or thepublic blockchain76 may be sent (via thecommunications network142 illustrated inFIGS. 22-23) to aserver162. Theserver162 may then add another, third layer of cryptographic hashing (perhaps using the hashing algorithm148) and generate another or secondpublic blockchain164. While theserver162 and/or thepublic blockchain164 may be operated by, or generated for, any entity, exemplary embodiments may integrate another cryptographic coin mechanism. That is, theserver162 and/or thepublic blockchain164 may be associated with BITCOIN®, ETHEREUM®, RIPPLE®, or other cryptographic coin mechanism. Thecryptographic proof80 and/or thepublic blockchain76 may be publicly distributed and/or documented as evidentiary validation. Thecryptographic proof80 and/or thepublic blockchain76 may thus be historically and publicly anchored for public inspection and review.
• Exemplary embodiments may be applied regardless of networking environment. Exemplary embodiments may be easily adapted to stationary or mobile devices having cellular, wireless local area network (WI-FI®), near field, and/or BLUETOOTH® capability. Exemplary embodiments may be applied to mobile devices utilizing any portion of the electromagnetic spectrum and any signaling standard (such as the IEEE 802 family of standards, GSM/CDMA/TDMA or any cellular standard, and/or the ISM band). Exemplary embodiments, however, may be applied to any processor-controlled device operating in the radio-frequency domain and/or the Internet Protocol (IP) domain. Exemplary embodiments may be applied to any processor-controlled device utilizing a distributed computing network, such as the Internet (sometimes alternatively known as the “World Wide Web”), an intranet, a local-area network (LAN), and/or a wide-area network (WAN). Exemplary embodiments may be applied to any processor-controlled device utilizing power line technologies, in which signals are communicated via electrical wiring. Indeed, exemplary embodiments may be applied regardless of physical componentry, physical configuration, or communications standard(s).
• Exemplary embodiments may utilize any processing component, configuration, or system. Any processor could be multiple processors, which could include distributed processors or parallel processors in a single machine or multiple machines. The processor can be used in supporting a virtual processing environment. The processor could include a state machine, application specific integrated circuit (ASIC), programmable gate array (PGA) including a Field PGA, or state machine. When any of the processors execute instructions to perform “operations,” this could include the processor performing the operations directly and/or facilitating, directing, or cooperating with another device or component to perform the operations.
• Exemplary embodiments may packetize. When theentity server140 and thedata layer server74 communicate via thecommunications network142, theentity server140 and thedata layer server74 may collect, send, and retrieve information. The information may be formatted or generated as packets of data according to a packet protocol (such as the Internet Protocol). The packets of data contain bits or bytes of data describing the contents, or payload, of a message. A header of each packet of data may contain routing information identifying an origination address and/or a destination address.
• FIGS. 25-29 further illustrate theblockchain data layer72, according to exemplary embodiments. Theblockchain data layer72 chains hashed directory blocks170 of data into thepublic blockchain76. For example, theblockchain data layer72 accepts input data (such as the entity'sprivate blockchain24 illustrated inFIGS. 9-21) within a window of time. While the window of time may be configurable from fractions of seconds to hours, exemplary embodiments use ten (10) minute intervals.FIG. 25 illustrates a simple example of only three (3) directory blocks170a-c of data, but in practice there may be millions or billions of different blocks. Each directory block184 of data is linked to the preceding blocks in front and the following or trailing blocks behind. The links are created by hashing all the data within asingle directory block184 and then publishing that hash value within the next directory block.
• AsFIG. 26 illustrates, published data may be organized within chains172. Each chain172 is created with an entry that associates a correspondingchain identifier174. Eachentity32a-f, in other words, may have itscorresponding chain identifier174a-d. Theblockchain data layer72 may thus track any data associated with theentity32a-fwith its correspondingchain identifier174a-d. New and old data in time may be associated with, linked to, identified by, and/or retrieved using thechain identifier174a-d. Eachchain identifier174a-dthus functionally resembles a directory176a-d(e.g., files and folders) for organized data entries according to theentity32a-f.
• FIG. 27 illustrates the data records70 in theblockchain data layer72. As data is received as an input (such as theprivate blockchain24 and/or thedigital contract20 illustrated inFIGS. 9-21), data is recorded within theblockchain data layer72 as anentry180. While the data may have any size, small chunks (such as10KB) may be pieced together to create larger file sizes. One or more of theentries180 may be arranged into entry blocks182 representing each chain172 according to the correspondingchain identifier174. New entries for each chain172 are added to their respective entry block182 (again perhaps according to the corresponding chain identifier174). After theentries180 have been made within the proper entry blocks182, all the entry blocks182 are then placed within in thedirectory block184 generated within or occurring within awindow186 of time. While thewindow186 of time may be chosen within any range from seconds to hours, exemplary embodiments may use ten (10) minute intervals. That is, all the entry blocks182 generated every ten minutes are placed within in thedirectory block184.
• FIG. 28 illustrates cryptographic hashing. Thedata layer server74 executes thedata layer application154 to generate the data records70 in theblockchain data layer72. Thedata layer application154 may then instruct thedata layer server74 to execute thehashing algorithm148 on the data records70 (such as thedirectory block184 illustrated inFIGS. 25-27). Thehashing algorithm148 thus generates one ormore hash values150 as a result, and the hash values150 represent the hashed data records70. As one example, theblockchain data layer72 may apply a Merkle tree analysis to generate a Merkle root (representing a Merkle proof80) representing eachdirectory block184. Theblockchain data layer72 may then publish the Merkle proof80 (as this disclosure explains).
• FIG. 29 illustrates hierarchical hashing. The entity'sprivate software application40 provides thefirst layer130 of cryptographic hashing and generates theprivate blockchain24. Theentity32 then sends its private blockchain24 (perhaps referencing or specifying the digital contract20) to thedata layer server74. Thedata layer server74, executing thedata layer application154, generates theblockchain data layer72. Thedata layer application154 may optionally provide the second orintermediate layer132 of cryptographic hashing to generate thecryptographic proof80. Thedata layer application154 may also publish any of the data records70 as thepublic blockchain76, and thecryptographic proof80 may or may not also be published via thepublic blockchain76. Thepublic blockchain76 and/or thecryptographic proof80 may be optionally sent to theserver162 as an input to yet another public blockchain164 (again, such as BITCOIN®, ETHEREUM®, or RIPPLE®) for athird layer188 of cryptographic hashing and public publication. Thefirst layer130 and thesecond layer132 thus ride or sit atop a conventional public blockchain164 (again, such as BITCOIN®, ETHEREUM®, or RIPPLE®) and provide additional public and/or private cryptographic proofs80.
• Exemplary embodiments may use any hashing function. Many readers may be familiar with the SHA-256 hashing algorithm. The SHA-256 hashing algorithm acts on any electronic data or information to generate a256-bit hash value as a cryptographic key. The key is thus a unique digital signature. There are many hashing algorithms, though, and exemplary embodiments may be adapted to any hashing algorithm.
• FIGS. 30-32 are more detailed illustrations of thedigital contract20, according to exemplary embodiments. Theprivate entity32 sends itsprivate blockchain24 to the network address associated with thedata layer server74 that generates theblockchain data layer72. Theprivate blockchain24 may contain information representing the transaction records100 associated with the entity's private cryptocoinage60 (perhaps as one or more privately hashed blocks of data). Theprivate blockchain24 may also specify, or incorporate, information or data representing thesingle cryptographic address102 and/or the digital contract20 (e.g., thecontract identifier28 and the contractual parameters30). Thesingle cryptographic address102 and/or the digital contract20 (e.g., thecontract identifier28 and the contractual parameters30) may additionally or alternatively be separately sent from theentity server140 to the data layer server74 (perhaps via thecommunications network142 illustrated byFIGS. 22-23). Regardless, the entity'sprivate cryptocoinage60 may be associated with the digital contract20 (e.g., thecontract identifier28 and the contractual parameters30) and/or thesingle cryptographic address102. The transaction records100 and/or their privately hashed blocks of data may thus specify, include, reference, and/or be associated with, and/or identified by, thesingle cryptographic address102, thedigital contract20, thecontract identifier28, and/or thecontractual parameters30. Because the contract identifier28 (and/or its corresponding hash value) is an identifiable input to thedata layer server74 generating theblockchain data layer72, the data records70 may also carry or reference thecontract identifier28 and/or thecontractual parameters30. So, should theblockchain data layer72 create or issue itsown cryptocoinage120, thecryptocoinage120 may also reference, be identified by, or be associated with thesingle cryptographic address102 and/or thecontract identifier28 and/or thecontractual parameters30. Thesingle cryptographic address102, thecontract identifier28, and/or thecontractual parameters30 may thus common indicators or reference data for tracking both the entity'sprivate cryptocoinage60 and thecryptocoinage120 issued by theblockchain data layer72, according to the terms of thedigital contract20. The transaction records100 (representing entity's private cryptocoinage60) may thus be commonly mapped or identified to thecryptocoinage120 issued by theblockchain data layer72 and to thedigital contract20.
• FIG. 31 illustrates a simple illustration. Once the contract identifier28 (and/or its corresponding hash value) is received, thecontract identifier28 may propagate and be recorded within theblockchain data layer72. Thecontract identifier28, for example, may be recorded in any of theentries180. Theentry180, and thus thecontract identifier28, may then be recorded and/or arranged as theentry block182 and placed within thedirectory block184. Theentry180, theentry block182, and thedirectory block184 may thus reference, specify, or be associated with, thecontract identifier28. Thecontract identifier28 has thus propagated as informational content from theprivate blockchain24 and into and through theblockchain data layer72. Thecontract identifier28 thus hierarchically moves through the multiple layers of cryptographic hashing for public publication. Theblockchain data layer72 thus tracks the transaction records100 involving thecontract identifier28. In simple words, theblockchain data layer72 may track contractual performance of thedigital contract20 via the transaction records100 that reference or contain thecontract identifier28. Moreover, theblockchain data layer72 may also track ownership and transfer of the entity'sprivate cryptocoinage60 and thecryptocoinage120 issued by theblockchain data layer72, all via the common singlecryptographic address102 and/or thecontract identifier28.
• FIG. 32 illustrates more details. While thesingle cryptographic address102 and/or thecontract identifier28 may be any alphanumeric entry or biometric input,FIG. 24 illustrates acommon authentication mechanism190. Here the same orsimilar authentication mechanism190 is used to access both the entity'sprivate cryptocoinage60 and thecryptocoinage120 issued by theblockchain data layer72. If a user of theblockchain data layer72 satisfies theauthentication mechanism190, then exemplary embodiments may access both theprivate cryptocoinage60, thecryptocoinage120, and/or the data records70 associated with thecontract identifier28. As a simple example, suppose the user of theauthentication mechanism190 supplies information or data representing thesingle cryptographic address102 and/or thecontract identifier28. Thesingle cryptographic address102 and/or thecontract identifier28 may be any unique alphanumeric entry, biometric input, user identifier, or other authentication credential. For example, most readers are likely familiar with an alphanumeric username and password, which is acommon authentication mechanism190.FIG. 32, though, illustrates a passphrase192 (such as a multi-word mnemonic). When the entity'sprivate cryptocoinage60 is/are created, generated, or assigned, the entity'sprivate cryptocoinage60 may be assigned or associated with thepassphrase192. Thepassphrase192 is unique to the registered owner, possessor, or user of the entity'sprivate cryptocoinage60. Thepassphrase192 may even be hashed as a hash value and supplied to the blockchain data layer72 (as above explained). Thepassphrase192, in other words, may be hashed as thesingle cryptographic address102 and propagated within theblockchain environment22 to document the transaction records100 involving the entity'sprivate cryptocoinage60.
• Thepassphrase192 may also authenticate to thecryptocoinage120. If the user correctly supplies thepassphrase192, then the same user may conduct transactions involving thecryptocoinage120 issued by theblockchain data layer72 and/or involving thecontract identifier28 associated with thedigital contract20. Exemplary embodiments thus allow the user to order transactions and exchanges involving the entity'sprivate cryptocoinage60, thecryptocoinage120 issued by theblockchain data layer72, and/or thedigital contract20.
• FIGS. 33-35 further illustrate the access mechanism, according to exemplary embodiments. The fillingstation110 may be a public and/or private service for financial transactions involving the entity'sprivate cryptocoinage60, thecryptocoinage120 issued by theblockchain data layer72, and/or thedigital contract20.FIG. 33 illustrates the fillingstation110 as a software-as-a-service offered by the securedata layer server74 for accessing theblockchain data layer72. The fillingstation110, for example, may be a module within, or called by, thedata layer application154. A user accesses the fillingstation110 to conduct transactions involving herprivate cryptocoinage60, the cryptocoinage120 (issued by the blockchain data layer72), and/or thedigital contract20. While the fillingstation110 may have any user interface,FIG. 33 illustrates aweb interface194. That is, the fillingstation110 may be accessed via awebpage196. Thewebpage196 prompts the user to input her authentication credentials according to the authentication mechanism190 (such as typing thepassphrase192 into a data field or audibly speaking the passphrase192).
• FIG. 34 further illustrates theweb interface194. The user accesses the fillingstation110 using auser device200. While theuser device200 may be any processor-controlled device, most readers are familiar with asmartphone202. If thesmartphone202 correctly sends authentication credentials (such as thesingle cryptographic address102 and/orpassphrase192, as above explained), then thesmartphone202 may utilize theweb interface194 to thedata layer server74 and/or theblockchain data layer72. Thesmartphone202 executes a web browser and/or a mobile application to send arequest204 specifying an address or domain name associated with or representing the fillingstation110. Theweb interface194 to thedata layer server74 thus sends thewebpage196 as a response, and the user'ssmartphone202 downloads thewebpage196. Thesmartphone202 has a processor and memory device (not shown for simplicity) that causes a display of thewebpage196 as a graphical user interface (or “GUI”)206 on itsdisplay device208. TheGUI206 may generate one or more prompts or fields for specifying theauthentication mechanism190 and transactional options. For example, the user preferably enters, speaks, or otherwise provides thepassphrase192. Exemplary embodiments may or may not hash the authentication passphrase (using thehashing algorithm148 above explained) to produce or generate a hashed passphrase. Exemplary embodiments may then search theblockchain data layer72 for the data records70. That is, exemplary embodiments may query theblockchain data layer72 for a query parameter (such as thecontract identifier28 and/or its hashed value) and theblockchain data layer72 identifies the data records70 that match or reference the query parameter. The fillingstation110 may then process the data records70 to provide atransactional summary210 of thedigital contract20. The fillingstation110 may also allow the user to replenish an amount or value of theprivate cryptocoinage60 and/or thecryptocoinage120, even allowing the user to continue exchanging thecryptocoinage60 for access to theblockchain data layer72.
• Exemplary embodiments may thus share thecommon authentication mechanism190. If the entity'sprivate software application40 requires thesame passphrase192 to establish any terms of thedigital contract20, then thepassphrase192 may have been hashed and recorded within theblockchain data layer72. Thesingle cryptographic address102, thecontract identifier28, and/or thepassphrase192 may be associated with the data records70 representing thedigital contract20, the private cryptocoinage60 (issued by the entity32), and the cryptocoinage120 (issued by the blockchain data layer72). The fillingstation110 may thus identify any of the data records70 that are commonly associated with thecontract identifier28, the private cryptocoinage60 (issued by the entity32), and/or thecryptocoinage120. The fillingstation110 thus allows the user to exchangecryptocoinage60 and90 for access to theprivate blockchain24 and/or theblockchain data layer72.
• FIG. 35 illustrates a query mechanism. Here thedata layer server74 may access adatabase220 of data layer records. Thedatabase220 of data layer records provides a referential record of the informational content contained within theblockchain data layer72.FIG. 35 illustrates thedata layer server74 locally storing thedatabase220 of data layer records in itslocal memory device156, but thedatabase220 of data layer records may be remotely stored and accessed via thecommunications network142. Regardless, thedata layer server74 may query thedatabase220 of data layer records for thesingle cryptographic address102 and/or thecontract identifier28 and identify and/or retrieve any corresponding data records70. While thedatabase220 of data layer records may have any logical structure,FIG. 35 illustrates thedatabase220 of data layer records as a table222 that maps, converts, or translates thesingle cryptographic address102 and/or thecontract identifier28 to itscorresponding entry180,entry block182, and/or directory block184 within theblockchain data layer72. Whenever thedata layer server74 generates theentry180,entry block182, and/or directory block184, thedata layer server74 may add an entry to thedatabase220 of data layer records. Over time, then, thedatabase220 of data layer tracks a comprehensive historical repository of information that is electronically associated with itscorresponding contract identifier28. Thedata layer server74 may then read or retrieve theentry180,entry block182, and/or directory block184 containing or corresponding to thecontract identifier28.
• Exemplary embodiments thus present the entity-specific cryptocoinage60. Anyentity32 may create its ownprivate blockchain24, establish its entity-specific tokens62, and define or offerdigital contracts20. The entity-specific tokens62 may or may not have thevalue94. Thetradeable token66, for example, may have a market value based on supply and/or demand, thus allowing or causing thevalue94 of thetradeable token66 to rise/fall or to increase/decrease, based on market forces. Thecredit token64, however, may have a constant price or value, perhaps set by theentity32. The entity-specific tokens62 may be associated with thecontract identifier28, thus allowing a faster and simpler accounting scheme for machine executable contractual terms.
• Exemplary embodiments may thus create coinage on top of coinage. The hierarchical scheme (explained with reference toFIG. 29) allows theprivate entity32 to establish itsprivate cryptocoinage60 hierarchically above the traditional BITCOIN®, ETHEREUM®, or RIPPLE® coinage. The entity'sprivate data36 remains private, but the transaction records100 may be publicly documented or proved via the traditional BITCOIN®, ETHEREUM®, or RIPPLE® environment. Theprivate entity32, in other words, need to worry about or concern itself with public publication. Theprivate entity32 need only subscribe (e.g., pay for write access) to theblockchain data layer72. Thedigital contract20 may also be offered, executed, and documented by the transaction records100.
• FIG. 36 illustrates apublic entity230, according to exemplary embodiments. Here exemplary embodiments may be applied topublic data232 generated by thepublic entity230. Thepublic entity230 may be a city, state, or federal governmental agency, but thepublic entity230 may also be a contractor, non-governmental organization, or other actor that acts on behalf of the governmental agency. Thepublic entity230 operates apublic server234 and applies itssoftware application236 to itspublic data232 to generate itsgovernmental blockchain238. Thepublic entity230 may further generate/issue itscryptocoinage240 and offerdigital contracts20 for governmental, public services. Thedata layer server74 receives thegovernmental blockchain238 and generates theblockchain data layer72. Thedata layer server74 may then generate thepublic blockchain76 representing anydata records70 representing thepublic data232 and/or thecryptocoinage240.
• FIGS. 37-40 further illustrate contractual execution, according to exemplary embodiments. When the contract server42 (such as the data layer server74) receives theblockchain24, exemplary embodiments inspect theblockchain24 to identify thecontract identifier28 and/or thecontractual parameters30. Thecontract identifier28 and/or thecontractual parameters30 may be contained within theblock26 of data within theblockchain24. Thecontract identifier28 and/or thecontractual parameters30 may be additionally or alternatively be metadata contained within theblock26 of data, and/or thecontract identifier28 and/or thecontractual parameters30 may be a data, data field, and/or a file attachment. Thecontract identifier28 and/or thecontractual parameters30 may be information or data specified by theblockchain24 and/or by a packet header or body. Regardless, once thecontract identifier28 and/or thecontractual parameters30 are determined, exemplary embodiments may consult theelectronic database44 of contracts.
• FIG. 38 illustrates thedatabase44 of contracts. While thedatabase44 of contracts may have any logical structure, a relational database is perhaps easiest to understand.FIG. 38 thus illustrates thedatabase44 of contracts as an electronic table250 that maps, converts, or translates thecontract identifier28 and/or thecontractual parameters30 to their corresponding network resource(s)50. Thedatabase44 of contracts may thus be preconfigured or preloaded with entries that assign or associatedifferent contract identifiers28 and/orcontractual parameters30 to theircorresponding network resource50 that provides, processes, and/or executes the correspondingdigital contract20. As thedata layer server74 receives anyblockchain24, thedata layer server74 may inspect theblockchain24 for thecontract identifier28 and/or thecontractual parameters30. Thedata layer server74 may then query thedatabase44 of contracts for thecontract identifier28 and/or thecontractual parameters30 to identify thecomputer file46,server254,virtual machine256,Internet protocol address258, orother network resource50 that is responsible for executing thedigital contract20. Thedatabase44 of contracts may optionally contain entries that relate hashed values of thecontract identifier28 and/or thecontractual parameters30. Regardless, once thenetwork resource50 is identified, thedata layer server74 may direct, assign, or outsource thecontractual information30 to thenetwork resource50 for processing.
• FIG. 39 illustrates a simple example. Here thecontract identifier28 maps to afilename260 that is associated with, or that represents, thecomputer file46 that contains the programming language representing thedigital contract20. So, once thefilename260 is determined, thedata layer server74 may locally retrieve and execute thecomputer file46 that corresponds to, or is associated with, thefilename260. Thedata layer server74 may then execute thecomputer file46, perhaps based on parameters defined or described by the contractual parameters30 (such as party names, parameters associated with their respective performance obligations and terms, and consideration). Optionally, thedata layer server74 may retrieve the computer file46 (perhaps via thecommunications network146 illustrated byFIGS. 22-23) from a remote server, database, or other device. Regardless, as thecomputer file46 is executed, thedata layer server74 may generate the data records70 in theblockchain data layer72 describing the execution of thecomputer file46. For example, the data records70 may sequentially and/or serially track the execution of thecomputer file46, perhaps logging or documenting periodic or random updates as thecomputer file46 executes, perhaps along with timestamps toward completion. The data records70 may also log or document a final step or outcome of the programming language representing thedigital contract20. Again, then, theblockchain24 only referenced the digital contract20 (using thecontract identifier28 and/or the contractual parameters30). The actual execution of thedigital contract20 may be offloaded or outsourced to thedata layer server74.
• FIG. 40 illustrates another example. Here thedata layer server74 may only manage the execution of thedigital contract20 referenced by thecontract identifier28 and/or thecontractual parameters30. That is, thedata layer server74 may outsource the execution of thedigital contract20 to a vendor or supplier as a subcontractor process. Again, when thedata layer server74 receives theblockchain24, thedata layer server74 inspects theblockchain24 to identify thecontract identifier28 and/or thecontractual parameters30. Thedata layer server74 may then consult thedatabase44 of contracts. Here, though, thedatabase44 of contracts has entries that map or relate thecontract identifier28 to aremote server262 that executes thedigital contract20 as a cloud-based service (perhaps as a software-as-a-service or SAAS). Thedatabase44 of contracts may thus associate thecontract identifier28 to theInternet protocol address258 representing theremote server262 that executes thedigital contract20. Thedatabase44 of contracts may additionally or alternatively associate thecontract identifier28 to a uniform resource locator (or “URL”)264 representing theremote server262 that executes thedigital contract20. Regardless, once theremote server262 is determined, thedata layer server74 may retrieve and send aservice request266 to the remote server262 (via theInternet protocol address258 and/or theURL264 representing the remote server262). Theservice request266 specifies thecontract identifier28 and requests an execution of the correspondingdigital contract20. Theservice request266 may also specify thecontractual parameters30. When the remote server262 (perhaps operated on behalf of a third party) receives theservice request266, theremote server262 applies the parameters defined or described by thecontractual parameters30 to the programming code (such as the computer file46) representing thedigital contract20. Once thedigital contract20 is executed, theremote server262 may then send aservice response268 back to thedata layer server74, and theservice response268 comprises data or information describing an outcome of the digital contract20 (such as consideration, payment, or performance terms).
• Thedata layer server74 may generate the data records70 in theblockchain data layer72. For example, the data records70 may document the date and time that theservice request266 was sent to theremote server262. Moreover, as theremote server262 provides thedigital contract20 as a service, theremote server262 may send periodic orrandom service updates270 as the service is provided along with timestamps toward completion. Thedata layer server74 may thus generate the data records70 describing the service updates270 received from theremote server262. Thedata layer server74 may also generate the data records70 describing theservice response268 sent from theremote server262 describing an outcome of thedigital contract20.
• FIGS. 41-42 illustrate virtual execution, according to exemplary embodiments. Here thedata layer server74 may outsource or subcontract the execution of thedigital contract20 to a virtual machine (or “VM”)280. For example, thedata layer server74 may implement differentvirtual machines190, with eachvirtual machine190 processing and/or executing a particulardigital contract20, perhaps as a software service. Thedata layer server74 may provide virtual computing and/or virtual hardware resources to client devices, thus lending or sharing its hardware, computing, and programming resources. Thedata layer server74 may thus operate or function as a virtual, remote resource for providing contractual execution as software services. Suppose, for example, that thedata layer server74 implements four (4)virtual machines280a-d. In practice, though, thedata layer server74 may implement any number or instantiations of differentvirtual machines280 and/ordigital contracts20, depending on complexity and resources. Moreover, as a further simplification, assume that eachvirtual machine280a-dexecutes a different correspondingdigital contract20a-d. So, when thedata layer server74 receives theblockchain24, thedata layer server74 may inspect theblockchain24 for eachcontract identifier28a-dand/or the correspondingcontractual information28a-dand consult thedatabase44 of contracts.
• FIG. 42 further illustrates thedatabase44 of contracts. Here thedatabase44 of contracts may include entries that map thecontract identifier28 to the correspondingvirtual machine280. Thedatabase44 of contracts may thus be preconfigured or preloaded with entries that assign or associate eachvirtual machine280 to itscorresponding contract identifier28. Once thevirtual machine280 is identified, thedata layer server74 may then coordinate and/or manage the execution of the correspondingdigital contract20, perhaps based on thecontract information30. Suppose, for example, that thedata layer application154 has programming or code that functions or performs as a query handler. Thedata layer application154 inspects theblockchain24 for thecontract identifier28 and queries thedatabase44 of contracts (as above explained). Thedata layer application154 thus identifies and/or retrieves the correspondingvirtual machine280. Exemplary embodiments may thus determine whethercontract identifier28 matches or satisfies any of the entries specified by thedatabase44 of contracts.FIG. 42 illustrates entries that map thecontract identifier28 to its corresponding virtual machine280 (e.g., an address, processor core, identifier, or other indicator).
• Thedigital contract20 may then be executed. For example, once thecontract identifier28 and thevirtual machine280 are determined, thevirtual machine280 may then call, retrieve, and/or execute thecomputer file46 that provides thedigital contract20 as a virtual service or process.FIG. 42 illustrates thecomputer file46 locally stored and executed by thedata layer server74, but thecomputer file46 may be remotely stored, retrieved, and/or executed. Regardless, thevirtual machine280 may be instructed to retrieve, execute, and/or apply thecomputer file46, perhaps based on thecontractual information30.
• FIG. 42 also illustrates software services. Here thedatabase44 of contracts may include entries that map thecontract identifier28 to a corresponding software service provided by thevirtual machine280. Exemplary embodiments, in other words, may relate thecontract identifier28 to aservice identifier282. Theservice identifier282 is any alphanumeric combination, data, or hash value that uniquely identifies asoftware service284 provided by thevirtual machine280. Once thecontract identifier28, thesoftware service284, and/or thevirtual machine280 are determined, thevirtual machine280 may then provide thesoftware service284. Thesoftware service284 may execute thedigital contract20, perhaps based on thecontractual information30.
• FIG. 43 illustrates cryptographic affinities, according to exemplary embodiments. Here thedata layer server74 may create or generate acryptographic affinity290 describing contractual execution. This disclosure above explained how thedata layer server74 may generate the data records70 in theblockchain data layer72. This disclosure also above explained how the data records70 may document execution of thedigital contract20. Here, then, thecryptographic affinity290 may uniquely identify thedigital contract20 executed by thevirtual machine280. For example, once thecontract identifier28 and thevirtual machine280 are determined (as above explained), thehashing algorithm148 may generate aunique hash value150. That is, thehashing algorithm148 may hash thecontract identifier28 with a virtual machine (“VM”) identifier292 to generate thecryptographic affinity290. The virtual machine identifier292 is any alphanumeric combination, data, or hash value that uniquely identifies thevirtual machine280. Thecryptographic affinity290 may then be documented by the data records70 in theblockchain data layer72, thus evidencing the execution of thedigital contract20. Indeed, thecryptographic affinity290 may be published via thepublic blockchain76 as thecryptographic proof80, thus further publicly evidencing the execution of thedigital contract20.
• FIG. 44 illustrates virtual assignments based on theblockchain data layer72, according to exemplary embodiments. As this disclosure previously explained, exemplary embodiments may generate the data records70 representing the blockchain data layer72 (such as theentries180, the entry blocks182, and/or the directory blocks184 explained with reference toFIGS. 25-27). Exemplary embodiments may thus assign theblockchain24 and/or thevirtual machine280 that executes thedigital contract20, based on the number of theentries180, the entry blocks182, and/or the directory blocks184 generated within theblockchain data layer72. For example, as the data records70 are generated, thedata layer server74 may determine arate290 of generation. That is, as the data records70 are generated when or while executing thedigital contract20, exemplary embodiments may sum or count theentries180, the entry blocks182, and/or the directory blocks184 that are generated over time (such as per second, per minute, or other interval). Exemplary embodiments, for example, may call or initialize a counter having an initial value (such as zero). At an initial time (such as when theblockchain24 is received or when thecontract identifier28 is determined), the counter commences or starts counting or summing the number of theentries180, the entry blocks182, and/or the directory blocks184 (generated within the blockchain data layer72) that are commonly associated with or reference the blockchain24 (perhaps according to the chain ID174) and/or thecontract identifier28. The counter stops counting or incrementing at a final time and exemplary embodiments determine or read the final value or count. Exemplary embodiments may then calculate therate290 of generation as the sum or count over time and consult or query theelectronic database44 of contracts for therate290 of generation. Exemplary embodiments may thus define entries that map or associatedifferent rates290 of generation and/or ranges to theircorresponding contract identifier28 and/orvirtual machines280. If thedatabase44 of contracts has an entry that matches or satisfies therate290 of generation, exemplary embodiments identify the correspondingvirtual machine280.
• Therate290 of generation may thus be a feedback mechanism. As theblockchain24 is received. the data records70 are requested, and/or thedigital contract20 is executed, therate290 of generation of the data records70 may determine thevirtual machine280 that is assigned adequate capacity or bandwidth. One of theblockchains24 and/orvirtual machines280, for example, may be reserved fordigital contracts20 having a heavy, disproportionate, or abnormallylarge rate290 of generation. Another of theblockchains24 and/orvirtual machines280 may be reserved fordigital contracts20 having a medium, intermediate, or historicallyaverage rate290 of generation. Still anotherblockchain24 and/orvirtual machine280 may be reserved for thedigital contracts20 having a light, low, or historically belowaverage rate290 of generation. Therate290 of generation may thus be a gauge or measure of whichblockchain24,digital contract20, and/orvirtual machine280 is assigned the resources.
• Exemplary embodiments thus include a service environment. Exemplary embodiments may manage and/or execute many differentdigital contracts20 offered by many different vendors or suppliers. Indeed, thedata layer server74 may manage or even execute thedigital contracts20 while also generating theblockchain data layer72 as still another service. Thedata layer server74 may thus acts as a subcontractor or service provider, perhaps in a subscription or other compensation scheme. Any customer or client (such as theentity server140 explained with reference toFIGS. 22-23) may thus send or forward its private blockchain24 (generated from its private data36) to thedata layer server74 for management or execution of anydigital contract20. Thedata layer server74 may generate the data records70 of theblockchain data layer72 that document the management or execution of anydigital contract20. Moreover, thedata layer server74 may publicly publish thecryptographic proof80 within thepublic blockchain76, thus further documenting immutable evidence of the management or execution of anydigital contract20. Indeed, theentity server140 may also generate theblocks26 of data within theprivate blockchain24 that also document the date and time that the management or execution of anydigital contract20 was sent/requested. Theentity server140 may then pay or reward thedata layer server74 in exchange for thedigital contract20 and/or the data records70 in the blockchain data layer72 (such as granting itscrytpocoinage60 and120, as explained with reference toFIG. 19).
• Thedata layer server74 may thus servemany blockchains24 requesting many different contractual services. Thefinancial institution34, for example, may send or forward itsprivate blockchain36a(as illustrated with reference toFIGS. 20-21) to thedata layer server74 for application or execution of any digital contract20 (by specifying thecontract identifier20, as above explained). Theretailer122 may similarly send or forward itsprivate blockchain36bto thedata layer server74 for application or execution of anydigital contract20. Theonline website124 may also send or forward itsprivate blockchain36cto thedata layer server74 for application or execution of anydigital contract20. Thedata layer server74 may generate the data records70 of theblockchain data layer72 that document the management and/or execution of anydigital contract20, and thedata layer server74 may publicly publish eachcryptographic proof80 within thepublic blockchain76, thus further documenting immutable evidence of the management and/or execution of anydigital contract20. Theentity32 may then pay or reward thedata layer server74 via theirrespective crytpocoinage60 and120.
• Exemplary embodiments thus only need to identify thedigital contract20. Thecontract identifier28 and thecontractual parameters30 need only be informational content in theprivate blockchain24. Thecontract identifier28 is any digital identifying information that uniquely identifies or references thedigital contract20. Thecontract identifier28 may be an alphanumeric combination that uniquely identifies a vendor and/or version of thedigital contract20 and/or a processor or executioner of thedigital contract20. Thecontract identifier28 may be expressed as a unique hash value that is included within, or specified by, theprivate blockchain24. Similarly, thecontractual parameters30 may identify the parties to thedigital contract20, their respective performance obligations and terms, and consideration.
• FIGS. 45-51 illustrate an architectural scheme, according to exemplary embodiments. This disclosure above explained that thedata layer server74 may only manage the execution of thedigital contract20. The implementation and/or actual execution of thedigital contract20 may thus be separate from thedata layer server74 that generates theblockchain data layer72.FIG. 45, for example, illustrates thedata layer server74 communicating via thecommunications network142 with theremote server262. Thedata layer server74 generates theblockchain data layer72, and theremote server262 executes at least some portion of thedigital contract20. Theremote server262 may thus have a hardware processor300 (e.g., “μP”), application specific integrated circuit (ASIC), or other component that executes acontract application302 stored in alocal memory device304. Theremote server262 has a network interface to thecommunications network142, thus allowing two-way, bidirectional communication with thedata layer server74. Thecontract application302 includes instructions, code, and/or programs that cause theremote server262 to perform operations, such as executing at least some portion of thedigital contract20.
• FIG. 46 illustrates a request mechanism. Thedata layer application154, for example, identifies the contract identifier(s)28 and/or thecontractual parameters30 associated with or representing thedigital contract20. The contract identifier(s)28 and/or thecontractual parameters30 may be sent to thedata layer server74 as an input (such as from theentity server140, as explained with reference toFIGS. 22-24), or thecontract identifiers28 and/or thecontractual parameters30 may be contained as information in theprivate blockchain24. Regardless, thedata layer server74 may then identify the network address, IP address, URL, or other nomenclature representing theremote server262 that executes at least some portion of the digital contract20 (perhaps via thedatabase44 of contracts, as earlier explained). Thedata layer server74 sends theservice request266 to theremote server262, and theservice request266 may include or specify thecontract identifier28 and/or thecontractual parameters30. When theremote server262 receives theservice request266, theremote server262 applies thecontractual parameters30 to the portion of thedigital contract20 and generates acontractual result306. Theremote server262 may then send theservice response268 back to thedata layer server74, and theservice response268 may comprise thecontractual result306.
• Exemplary embodiments may thus exchange inputs and outputs. When thedata layer server74 sends theservice request266 to theremote server262, theservice request266 may include or specify one or more of thecontract identifiers28 and/or thecontractual parameters30. Suppose, for example, that thecontract identifiers28 and/or thecontractual parameters30 are represented as hash values. The hash values may be identified from, or specified by, theprivate blockchain24. The hash values may additionally or alternatively be generated by the data layer application154 (such as by calling, invoking, or executing thehashing algorithm148, as above explained). Regardless, theservice request266 may thus include or specify the hash values representing thecontract identifiers28 and/or thecontractual parameters30. When theremote server262 receives theservice request266, thecontract application302 may use or accept the hash values as inputs to generate thecontractual result306 as an output. Thecontract application302 may further encrypt the contractual result306 (such as calling, invoking, or executing the hashing algorithm148) to generate another hash value representing thecontractual result306.
• Exemplary embodiments provide contractual proofs. When thedata layer server74 sends theservice request266 to theremote server262, the data records70 may document theservice request266 as one of the cryptographic proofs80. When thedata layer server74 receives theservice response268, the data records70 document that receipt and thecontractual result306 as another one of the cryptographic proofs80. The data records70 thus prove that at least the portion of thedigital contract20 was outsourced to a vendor or supplier as a subcontractor process or assignment. The data records70 also prove that at least the portion of thedigital contract20 was executed to provide thecontractual result306. Thedata layer server74 may then compare the contractual result306 (such as its hash value) to a predefined or expect value. If thecontractual result306 matches or equals the predefined or expect value, then thedata layer application154 may be programmed or coded to infer that the contract successfully executed and/or the vendor or supplier performed as obligated. However, if thecontractual result306 fails to match or equal the predefined or expect value, then thedata layer application154 may be programmed or coded to infer that the contract is not satisfied and/or the vendor or supplier failed to perform as obligated.
• FIG. 47 illustrates a layered contractual process. Here thedigital contract20 may have different or individual components, portions, or sub-parts that cumulatively combine to produce thecontractual result306. The different components, portions, or sub-parts may be software modules310 that can be separately executed to generate the overall or finalcontractual result306. A simpledigital contract20, for example, may only have a few or several software subroutines or modules310, while a complex or complicateddigital contract20 may have many or hundreds of different software subroutines or modules310. As the reader likely understands, such a complicated software structure is too difficult to illustrate. For simplicity, then,FIG. 47 illustrates thedigital contract20 having four (4) software modules310a-d. Theentire contract application302, in other words, may have four (4) different application layers312a-d. Each componentry module310a-dor layer312a-dmay have its owncorresponding contract identifier28a-d. When theremote server262 receives theservice request266, exemplary embodiments may then feed thecontractual parameters30 as inputs314a-dto the software modules310a-d. Each different software module310 may thus generate its respective orcorresponding output316a-d, which may be combined or processed to generate the overall or finalcontractual result306.
• FIG. 48 illustrates hierarchical execution. Here the different software modules310 may be serially or sequentially executed to generate the overall or finalcontractual result306. For example, thesoftware module310amay accept at least some of thecontractual parameters30 as theinput314a, execute its respective programming code, and generate itscorresponding output316a. Here, though, theoutput316amay then be routed or sent to thesoftware module310b(illustrated as theapplication layer312b) as itsinput314b. Its respective programming code is then executed to generate itscorresponding output316b, based on theoutput316agenerated by or received from thesoftware module310a. Similarly,software module310caccepts theoutput316band generatesoutput316c, which is received bysoftware module310dasinput314dand used to generate theoutput316d. While exemplary embodiments may continue processing theoutputs316a-dto generate any desired outcome, for simplicityFIG. 40 illustrates theoutput316das the finalcontractual result306. Exemplary embodiments may thus use the software modules310a-das feedback mechanisms to monitor or even enforce contractual rule-based obligations defined or specified by thedigital contract20.
• FIG. 49 illustrates theblockchain data layer72. Here theblockchain data layer72 may document the processing and/or execution of each software module310a-d, its respective input(s)314a-d, its respective output(s)316a-d, and perhaps a corresponding timestamp (not shown for simplicity). The data records70 may further document or record the correspondingcontract identifier28a-dand/or thechain identifier174. Thedata layer server74 may thus receive the service updates270 (via the communications network142) as each software module310a-dperforms or executes its corresponding contractual service. Thedata layer server74 may then generate the data records70 in theblockchain data layer72, thus documenting each software component's contribution toward the overall or finalcontractual result306. The data records70 may also be hashed to generate thecryptographic proofs80, as above explained.
• FIG. 50 also illustrates contractual execution. Here, though, the different software modules310 may be executed by different devices. Suppose, for example, that theremote server262alocally stores and executes thesoftware module310a, while theremote server262blocally stores and executes thesoftware module310b. Suppose also that theremote server262clocally stores and executes thesoftware module310cand theremote server262dlocally stores and executes thesoftware module310d. Exemplary embodiments may thus source or subcontract the different portions of thedigital contract20 to different machines for execution. Theremote server262a, for example, may specialize in thesoftware module310a. Theremote server262amay thus accept theservice request266 from clients, execute thesoftware module310a, and return send the service response268 (as explained with reference toFIG. 46). Theremote server262amay also send the service update(s)270 to thedata layer server74, thus allowing theblockchain data layer72 to document the contractual service provided by thesoftware module310a. Theremote servers262b-d may similarly specialize in thesoftware modules310b-d to provide their respective contractual services.
• FIG. 51 illustrates an overall architectural scheme. As the reader may envision, there may be hundreds, thousands, millions, or even billions of contractual relationships between many different parties. As smart, digital contracts grow in acceptance and usage, theblockchain data layer72 is expected to exponentially grow, thus requiring ever-increasing hardware and software resources. In plain words, there may be manydata layer servers74 generating the data records70 in theblockchain data layer72. While there may be hundreds or even thousands ofdata layer servers74,FIG. 51 simply illustrates four (4)data layer servers74a-dthat cooperate to generate theblockchain data layer72. As the processing load increases or grows (such as according to therate290 of generation, as above explained), the number ofdata layer servers74 may also grow.
• Theblockchain data layer72 may thus be separate from an implementation and execution of thedigital contract20. Thedata layer servers74, in other words, may be separately networked and/or addressed from theremote servers262 providing the contractual services representing the software modules310 of thedigital contract20. Any of thedata layer servers74 may send data or information as inputs to any one of theremote servers262, and the corresponding software module310 performs its contractual service and sends itsoutput316 back to the blockchain data layer72 (perhaps via theservice request266, theservice response268, and theservice update270 as earlier explained and illustrated). Some of theremote servers262 may provide virtual services, such as a virtual machine (as above explained) that executes any of the software modules310.
• FIG. 52 illustrates compliance scheme, according to exemplary embodiments. As the reader may understand, some smart, digital contracts have jurisdictional requirements. For example, thedigital contract20 may have programming code that requires an execution or processing in a particular region or country. That is, thedigital contract20 may have contractual rules and/or provisions that must be enforced in the United States, the European Union, or the Isle of Man. Components or portions of thedigital contract20 may require execution or location in the Cayman Islands, Idaho, or Hong Kong. Thedigital contract20, in other words, may have ageographic parameter320. Thegeographic parameter320 may be a locational requirement, restriction, or preference for at least some portion of thedigital contract20. Thegeographic parameter320 can be any data, information, field, metadata, or code for enforcing the locational requirement, restriction, or preference. Indeed, thegeographic parameter320 may even be finely expressed or defined as global positioning system (“GPS”) information or coordinates at which at least some portion of thedigital contract20 must be processed or executed.
• Thegeographic parameter320 may be an input value. AsFIG. 52 illustrates, thegeographic parameter320 may be read or received via the private blockchain24 (perhaps along with thecontract identifier28 and/or the contractual parameter30). Thedata layer server74, in other words, may identify thegeographic parameter320 as data, information, or a hash value contained within theblock26 of data. However, thegeographic parameter320 may additionally or alternatively be received and/or identified within a header of body/payload of apacket322 of data (packetized according to the Internet Protocol, just as thecontract identifier28 and/or thecontractual parameter30 may be identified).
• Regardless, once thegeographic parameter320 is determined, exemplary embodiments may again consult thedatabase44 of contracts. Thedatabase44 of contracts may have entries that electronically associate the contract identifier(s)28 and/or the contractual parameter(s)30 to thegeographic parameter320. Thedata layer application154 may instruct thedata layer server74 to query thedatabase44 of contracts for either, any, or all of thecontract identifiers28, thecontractual parameters30, and/or thegeographic parameters320 to identify and/or retrieve the corresponding database entries. As a simple example, suppose a file component of thedigital contract20 must be processed in a particular geographic region (such as the British Virgin Islands or Canada). Thecorresponding contract identifier28, in other words, may be electronically associated with a particular geographic region, as defined by a tabular entry in thedatabase44 of contracts. Once the region is determined, thedata layer server74 may then route thecontract identifier28, thecontractual parameter30, and/or thegeographic parameter320 to theremote server262 that is associated with, or even located within, the region. Exemplary embodiments, for example, may implement theservice request266, theservice response268, and the service update270 (as earlier explained). Theremote server262 may then process or execute thedigital contract20 using thecontract identifier28 and/or the contractual parameter30 (as this disclosure earlier explained).
• Other examples explain thegeographic parameter320. Suppose that thecontract identifier28 and/or thecontractual parameter30 map(s) to a particular server, cluster of servers, and/or a particular virtual machine (“VM”). Thedata layer server74 may then route thecontract identifier28, thecontractual parameter30, and/or thegeographic parameter320 to theremote server262 that is associated with the cluster of servers and/or the virtual machine. Theremote server262 may then process or execute thedigital contract20 using thecontract identifier28 and/or the contractual parameter30 (as this disclosure earlier explained). More likely, though, thecontract identifier28 and/or thecontractual parameter30 will relate to a particular IP address or uniform resource locator (“URL”). Thedata layer server74 may then route thecontract identifier28, thecontractual parameter30, and/or thegeographic parameter320 to theremote server262 that is associated with the IP address or URL for processing (again, as this disclosure earlier explained).
• Exemplary embodiments may thus implement contractual provisions. Somedigital contracts20 may require a particular server, perhaps implementing or hosting a particular website, network, authentication scheme, programming, or othergeographic parameter320. Some parties to thedigital contract20 may also require a particular server, perhaps as specified by thegeographic parameter320. Somedigital contracts20 may have compliance obligations, perhaps defined by a particular jurisdiction and expressed as thegeographic parameter320. Servers, webpages, networks and other resources may be dedicated to specific jurisdictions, as expressed by thegeographic parameter320.
• FIGS. 53-59 illustrate a decisional architecture and scheme, according to exemplary embodiments. Even though theblockchain environment22 enables an execution of the smart,digital contract20, some digital contracts may be too complex and/or too cumbersome to implement on theblockchain24. As this disclosure above explains, exemplary embodiments may thus put smaller contractual components of thedigital contract20 on any blockchain (such as theprivate blockchain24 or the public blockchain76), validate the contractual components (perhaps via the cryptographic proof80), incorporate thecryptographic proof80 into a larger component of thedigital contract20, and then validate the larger component.
• Exemplary embodiments may further implement one or more decision tables326. As the reader may understand, the decision table326 may be used to implement at least a component of thedigital contract20. That is, the decision table326 may represent one or more rules orlogic conditions328, one ormore inputs330, and one or moredecisional outputs332. The decision table326 may thus be visually represented as a table having rows and columns. In simple words, once theinput330 is known, a processing or execution engine (such as theentity server140 or other device) electronically maps or associates theinput330 to the appropriate rule orlogic condition328 and generates thedecisional output332. Exemplary embodiments may then log or record thedecisional output332, along with its corresponding theinput330, rule orlogic condition328, and a date/time stamp.
• Exemplary embodiments may thus document any decision. In general, the smart,digital contract20 is an agreement between parties/participants about services, products, and/or money. In order to make thedecisional output332, information is provided (such as the input330) and the rule orlogic condition328 is executed. In an interactive process, each party/participant might contribute data to a single decision. In other words, the parties may exchange data to perform thedecisional output332. Exemplary embodiments may thus map each decisional output332 (perhaps representing a decision model) to a decision taken by a single party. Each party, in other words, may communicatively exchange the result of its decision such that others can base their decisions on theirdecisional output332, thus collaboratively executing the different components of thedigital contract20.
• FIG. 54 illustrates an impartial, trusted intermediary. When any party or participant to thedigital contract20 acts or executes, exemplary embodiments may log or archive their respective action(s). For example, thedata layer server74 may be informed of any decision-making process. Suppose, for example, that the entity32 (acting as a party to the digital contract20) wishes to document or prove its contractual performance. That is, theentity server140 sends its decisional output332 (perhaps via thecommunications network142 illustrated inFIGS. 22-23) to thedata layer server74 for documentation. Thedecisional output332 may thus be read or received via the private blockchain24 (perhaps along with thecontract identifier28 and/or the contractual parameter30). Thedata layer server74, in other words, may identify thedecisional output332, along with itscorresponding input330, its rule orlogic condition328, and the date/time stamp, as data, information, or hash values contained within theblock26 of data (asFIG. 53 illustrated). However, the decisional output332 (and/or thecontract identifier28, thecontractual parameter30, theinput330, the rule orlogic condition328, and the date/time stamp) may additionally or alternatively be received and/or identified within a header of body/payload of thepacket322 of data (packetized according to the Internet Protocol).
• Regardless, thedata layer server74 may then generate the data records70 in theblockchain data layer72, as this disclosure above explained. The data records70 log or record the decisional output332 (sent from the party participant), along with itscorresponding input330, the decision table326, the rule orlogic condition328, and the date/time stamp of performance. Theblockchain data layer72, in other words, provides neutral, documentary evidence that the party executed its transactional portion of the smart,digital contract20. Moreover, theblockchain data layer72 may also add another layer of cryptographic hashing to generate thepublic blockchain76 and thecryptographic proof80. Theblockchain data layer72 thus may again act as thevalidation service78 that validates the party performed its portion of thedigital contract20. Exemplary embodiments may thus be used as an audit trail to reconstruct the party's decision-making process and who provided theinput330.
• Exemplary embodiments may even document fine granularity. When thedata layer server74 receives thedecisional output332, the data or information may even identify or pinpoint thenetwork resource250. That is, when entity32 (acting as a party to the digital contract20) wishes to document or prove its contractual performance, thedecisional output332 may even include data or information identifying theparticular server254 or cluster orvirtual machine256 that generated thedecisional output332. Indeed, the data or information may even identify or pinpoint the particular IP address or uniform resource locator (“URL”). The data records70 may thus document the machine, manufacturer, model, and/or chassis hardware inventory that performed the portion of thedigital contract20.
• FIG. 55 illustrates contractual management. Here again thedata layer server74 may manage the execution of thedigital contract20. When any party, participant, or subcontractor performs a portion or component of thedigital contract20, thedata layer server74 may coordinate and validate the contractual components. Suppose again that thedata layer server74 receives thecontract identifier28 and/or the contractual parameters30 (as earlier explained). Thecontract identifier28 may represent a single, largedigital contract20. Thecontract identifier28, however, may represent only a single or a few contractual components of thedigital contract20. Thecontract identifier28, in other words, may map or relate to a sequence or series of one ormore table identifiers334. Eachtable identifier334 may be an alphanumeric combination or a unique hash value. Regardless, eachtable identifier334 uniquely identifies the corresponding decision table326 that decides a componentry portion of thedigital contract20. When thedata layer server74 receives the one ormore contract identifiers28, thedata layer server74 may then consult thedatabase44 of contracts.
• FIG. 56 further illustrates thedatabase44 of contracts. Here thedatabase44 of contracts may have additional entries that map or relate thecontract identifier28 to thetable identifier334 and/or to thenetwork resource250 that executes the corresponding componentry portion of the digital contract20 (perhaps again as a cloud-based service). Thecontract identifier28, in other words, may map or relate to a sequence or series of one ormore table identifiers334. Eachtable identifier334 may be an alphanumeric combination or a unique hash value. Regardless, eachtable identifier334 uniquely identifies the corresponding decision table326 that decides a componentry portion of thedigital contract20. When thedata layer server74 receives the one ormore contract identifiers28, thedata layer server74 may then consult thedatabase44 of contracts to determine any corresponding entry (as this disclosure above explains).
• FIG. 57 illustrates outsourcing. Once thenetwork resource50 is determined (recall that thenetwork resource50 may execute the corresponding componentry portion of the digital contract20), thedata layer server74 may utilize the request mechanism. Suppose, for example, that thedatabase44 of contracts identifies theremote server262 as thenetwork resource50. Thedata layer server74 may thus instruct theremote server262 to execute the corresponding decision table326. Thedata layer server74, for example, sends the service request266 (as earlier explained), and theservice request266 may specify thetable identifier334 and/or theinput330 as thecontractual parameters30. When theremote server262 receives theservice request266, theremote server262 applies theinput330 to the decision table326 representing thedigital contract20. Once thedecisional output332 is determined, theremote server262 may then send theservice response268 back to thedata layer server74, and theservice response268 comprises data or information describing thedecisional output332. Thedata layer server74 may generate the data records70 in theblockchain data layer72 that document theservice request266 and theservice response268, perhaps including anyservice updates270 as the decision table326 is executed.
• FIG. 58 illustrates contractual participation. Here thedata layer server74 may execute at least a componentry portion of thedigital contract20. That is, thedata layer server74 may locally store and/or access one or more of the decision tables326 representing thedigital contract20. When thedata layer server74 receives thecontract identifier28 and/or the contractual parameters30 (as earlier explained), thedata layer server74 may consult thedatabase44 of contracts. Here, though, thedatabase44 of contracts has one or more entries that map or relate thecontract identifier28 to thevirtual machine280 that executes the decision table326. Thedatabase44 of contracts may thus electronically associate thecontract identifier28 to the table identifier(s)334 and the virtual machine(s)280 that locally execute the decision table(s)326. The decisions table326 may thus have virtual assignments. Once thevirtual machine280 and/or the decision table326 is determined, thevirtual machine280 is requested or instructed to apply theinput330 to the corresponding decision table326 to generate thedecisional output332. Thedata layer server74 may then generate the data records70 in theblockchain data layer72 that document the local contractual performance (as earlier explained).
• AsFIG. 58 illustrates, feedback may be used. Exemplary embodiments may assign thevirtual machine280 based on the data records70 in theblockchain data layer72. That is, as the decision table326 consumes more and more of the data records70 (e.g., the number of theentries180, the entry blocks182, and/or the directory blocks184 generated within theblockchain data layer72, as earlier explained), therate290 of generation may be used as a feedback mechanism (as this disclosure earlier explained). Highly used or called decision tables326, in other words, may be assigned tovirtual machines280 having greater capacity or bandwidth. Thedatabase44 of contracts may thus define entries that map or associatedifferent rates290 of generation and/or ranges to theircorresponding table identifier334 and/orvirtual machines280. If thedatabase44 of contracts has an entry that matches or satisfies therate290 of generation, exemplary embodiments identify the correspondingvirtual machine280. Somevirtual machines280, for example, may be reserved for decision tables326 having a heavy, disproportionate, or abnormallylarge rate290 of generation. Othervirtual machines280 may be reserved for decision tables326 having intermediate andlow rates290 of generation. Therate290 of generation may thus be a gauge or measure of whichvirtual machine280 is assigned the decision table326.
• Exemplary embodiments thus include a service environment. Exemplary embodiments may manage and/or execute many different decision tables326 offered by many different vendors or suppliers. Indeed, thedata layer server74 may manage or even execute thedigital contracts20 while also generating theblockchain data layer72 as still another service. Thedata layer server74 may thus acts as a subcontractor or service provider, perhaps in a subscription or other compensation scheme. Any customer or client may thus send or forward itsinput330 and/or itsdecisional output332 to thedata layer server74 for management or execution of anydigital contract20. Thedata layer server74 may generate the data records70 of theblockchain data layer72 that document the management or execution of any portion of component of thedigital contract20. Moreover, thedata layer server74 may publicly publish thecryptographic proof80 within thepublic blockchain76, thus further documenting immutable evidence of the management or execution of anydigital contract20. Any party, participant, or vendor/subcontractor may then pay or reward the data layer server74 (such as granting itscrytpocoinage60 and120, as explained with reference toFIG. 19).
• Thedata layer server74 may thus provide contractual services. Thefinancial institution34, for example, may send or forward itsinput330 and/or itsdecisional output332 to thedata layer server74 for contractual documentation. Similarly, theretailer122, theonline website124, and themanufacturer128 may also send itsinput330 and/or itsdecisional output332 to thedata layer server74 for contractual documentation. Thedata layer server74 may generate the data records70 of theblockchain data layer72 that document the management and/or execution of any decision table326 representing any portion of thedigital contract20. Thedata layer server74 may also publicly publish eachcryptographic proof80 within thepublic blockchain76, thus further documenting immutable evidence of the management and/or execution of anydigital contract20. Thedata layer server74 may be paid or rewarded via theirrespective crytpocoinage60 and120.
• Exemplary embodiments may thus create factored decision tables driven by a table engine. Smart, digital contracts are notoriously dangerous. Decision tables are significantly easier to verify and validate. However, decision tables may be large and perhaps cannot be placed on a blockchain. Exemplary embodiments may thus put smaller contractual components of thedigital contract20 on any blockchain (such as theprivate blockchain24 or the public blockchain76), validate the contractual components (perhaps via the cryptographic proof80), incorporate thecryptographic proof80 into a larger component of thedigital contract20, and then validate the larger component.
• Exemplary embodiments thus may separate the blockchaindata layer data72 from contractual execution. The data layer server74 (generating the blockchain data layer data72) may thus accept inputs from the servers (such as the remote server262) executing any component of thedigital contract20. The servers (such as the remote server262) executing any component of thedigital contract20 may also send data to thedata layer server74. Thedata layer server74 may thus execute the decision table. Theremote server262 may additionally or alternatively execute the decision table when processing thedigital contract20. The decision table may thus be sent and/or received as an input/output. Even a virtual machine may access and use the decision table.
• Exemplary embodiments thus establish thedigital contract20 as an identity. Because only thecontract identifier28 is needed, thedigital contract20 may be separated into various smaller components (such as the software modules310 and/or layers312, as above explained). Each software module310 and/or layer312 may have itsown contract identifier28. Thedigital contract20 is thus transformed to an identity, which may be easily updated after software bugs are found and consensus is documented by stake holders. Exemplary embodiments thus provide an ability to repair bugs and to claw back or backup spurious results. The separation of the blockchaindata layer data72 thus isolates and protects the data records70.
• Exemplary embodiments thus describe a novel smart contract architecture to be run on blockchains. Thedigital contract20, and/or its contractual components, may each have its own digital identity defined within the blockchaindata layer data72. Thecontract identifier28, in other words, may uniquely identity a version, thus allowing stakeholders (using their digital identities) to approve updates to respond to changes in business, to approve bug resolution, and to accommodate new participants in thedigital contract20, without having to dissolve the original version and without redeploying or requiring the blockchain to be reversed and modified to avoid an incorrect, improper, or unacceptable result by perhaps a majority of users. As the reader may understand, modifying a blockchain to resolve an issue involves many more stakeholders with an interest in the blockchain but having no interest in the smart contract. This has been a problem with conventional blockchain architectures.
• Exemplary embodiments may separate the blockchaindata layer data72 from the rules engine architecture that executes thedigital contract20. Exemplary embodiments allow for light weight, secure, and extendible digital identity. Digital identity can be applied to implementation of the virtual machine that runs thedigital contract20. Digital identity can be applied to any smart contract and/or to any stakeholder(s). Stakeholders may thus be paid (perhaps via the cryptocurrencies as explained with reference toFIGS. 13 & 15-21) for who they are, such as to a particular blockchain address, meaning if a stakeholder's address is compromised, then the stakeholder can update the address without having to modify thedigital contract20. This virtual address modification is similar to the real world for when a business moves from one geographic location to another, the business does not invalidate all its contracts. In the real world, the business merely informs parties of its new physical address and contact information. Exemplary embodiments allow management of thedigital contract20 in a flexible fashion, similar to management of contracts in the real world, but with blockchain security and data integrity of the actualdigital contract20, automation of provisions in thedigital contract20, and cryptopayment support.
• Exemplary embodiments are also scalable. Layers or modules310 and312 can be created in thedigital contract20 and/or in theprivate blockchain24 or thepublic blockchain76 for improved flexibility and management via hardware computers. The data records70 in the blockchaindata layer data72 are safely separated from the servers that execute thedigital contract20. Contract servers (e.g., the contractual application layer) may perform a decentralized evaluation ofdigital contract20, using the proper virtual machine and proper rules, and manage interests of majority or all stakeholders. Values of cryptotokens may be defined and/or distributed, but allowing greater scalability.
• Exemplary embodiments provide numerous advantages. Because the contractual execution is separate from the blockchaindata layer data72, the results of thedigital contract20 are securely documented and may be exported to other contractual components or to other digital contracts. Exemplary embodiments may thus implement and offer multiple modules310, layers312, or instances of different contractual components that can exchange inputs and outputs to build a networking effect between different layers, modules, and smart contracts. A first server running a first application layer (and perhaps executing a first smart contract) can be entirely separate a second server running a second smart contract and a third server running a third smart contract. Theblockchain data layer72, though, exchanges and thus documents their respective inputs and outputs. The various servers may thus manage and/or share the same cryptotokens, or different entity tokens may be exchanged within each layer. Regardless, exemplary embodiments may coordinate exchanges of value for services performed. Great flexibility in defining the value of cryptotokens and the value into and out of smart contract.
• Exemplary embodiments may also have jurisdictional advantages. Particular servers may be specific to particular jurisdictions and/or particular smart contracts. For example, some application layers may cross jurisdictional servers with different compliances. As another example, suppose that one application layer may require qualified investors with full know your client (or “KYC”) compliance. Another application layer may be anonymous and/or allow all corners. Even if theblockchain data layer72 has a small set of users/clients, large smart contracts may be managed, implemented, and/or documented.
• Thedigital contract20 may utilize conventional programming languages and/or decision tables. In particular, some programming languages and decision tables, like purely functional languages, may mathematically prove contractual algorithms. These mathematical proofs may yield much more secure smart contracts than conventional languages that run on today's blockchains. Previously, smart contracts were often too big in size to execute on a blockchain. The separateblockchain data layer72, though, allows scaling and implementing smart contracts “off chain.” Theproof80 of thedigital contract20, for example, is a hash value, perhaps in association with thecontract identifier28 and/or thechain identifier174, as documented by the data records70 in theblockchain data layer72. The hash value of the proof80, in other words, is a very small value (in relation to the size of the smart contract). Thedigital contract20 may thus be provided to any or all parties and/or any or all stakeholders for validation of its terms, obligations, and performance. Thecryptographic proof80 thus verifies execution without stuffing large amounts of data onto theprivate blockchain24 or thepublic blockchain76.
• Exemplary embodiments may use decision tables for smart contracts. Decision tables are well understood, perform well, and are verifiable relative to brute-force code writing. Simply put, custom programming code introduces many variables and software bugs are inevitable. Decision tables are also very amenable to domain-specific languages. As the reader may understand, domain-specific languages accept near-English statements as inputs and generate computer code as outputs. Subject matter experts may thus define the functionality of thedigital contract20, perhaps without relying on the skills of computer programmers (who may not fully understand the subject matter). Decision tables are thus approachable to subject matter experts and easily implemented. Decision tables may also be combined with other decision tables, which allows performance proven and validated functions may be incorporated into smart contracts for many objectives and outcomes. Decision tables may thus be mixed and matched as components to a compositedigital contract20, and a collection of decision tables representing thedigital contract20 may still be validated to ensure correct operation. Decision tables define much smaller numbers of programming paths through the software code representing thedigital contract20, which ensures that all contractual combinations may be enumerated and proper results can be expected for a range of values. On blockchains, though, decision tables may be big in size, so some decision tables may not be feasible as a smart contract on a conventional blockchain. But, because theblockchain data layer74 is separate from theremote servers262 executing thedigital contract20, the digital identity (e.g., the contract identifier28) for the digital contract20 (that allows the smart contract to exist off chain) provides the servers (each perhaps having its own identity) to certify execution of thedigital contract20. Exemplary embodiments may also define the mechanism for cryptotoken-based payments that incentivize theremote server262 to perform thedigital contract20 and to verify and validate thedigital contract20. Component and composite performance may be tracked, recorded, and proved. For example, if a virtual machine runs the digital contract20 (as above explained), execution in the virtual environment can be tracked. Virtual machines may often have software bugs that affect an interpretation of the decision tables. The virtual machine may thus have its own digital identity, as defined by thedatabase44 of contracts (as above explained). Different versions of the virtual machine and/or the decision table may thus be mapped within thedatabase44 of contracts, thus allowing redirection after software bugs have been resolved. Thedatabase44 of contracts, in other words, may be updated with entries that point to different versions for different parties and/or to corrected or improved versions.
• Digital identities extend to engines and decision tables. Thedatabase44 of contracts may map or point to servers, domains, decision tables, and their respective versions. The digital contract20 (and/or its components, as represented by their respective contract identifiers28) ensures execution, regardless of the environment. Because theblockchain data layer72 documents all this component processing, the data records70 may prove (via the cryptographic proof80) that the correct contractual component was used, the correct decision table(s) was/were used, the correct virtual machine was used, and the correct input or output data was used. Verification may driven from the contractual components, the data components, and the hardware components at the correct time for the correct time period.
• Another audit application example is provided. A software application may be a generic term for user-side software that reads from and/or writes to the Factom system. It could be software with a human interface, or could be completely automated. The Application is interested in the data organized by the Chains it needs.
• Applications are possibly Distributed Applications (DApps) interacting with Factom to provide additional services. For example, one might imagine a trading engine that processes transactions very fast, with very accurate timestamping. Such an Application may nonetheless stream transactions out into Factom chains to document and secure the ledger for the engine. Such a mechanism could provide real-time cryptographic proof of process, of reserves, and of communications.
• Let us explore two separate applications that could have immediate demand in the current Bitcoin ecosystem.
• Let us see how to implement a secure and distributed log platform. Log analysis is a complex task. Additionally, logs tend to be easily forgeable and also heterogeneous as they are produced by each system independently and stored in a variety of media (files, databases, cloud services etc.). With Factom and a few uniquely designed crypto-audit tools an entities log analysis can become safer, simpler, and much more powerful. Let's see this with an example. Suppose a Bank (B), a Payment Provider (PP), and a Bitcoin company (BC) are interacting together as follows:
• • 1—The User goes to the BC website and wants to buy some bitcoins
  • 2—He asks for a quote, which is valid for5 minutes
  • 3—Then he is redirected to the PP website
  • 4—Then the PP connects with the B platform so that the money of the user account is debited
  • 5—B notifies PP that the user account has been debited
  • 6—PP notifies BC
  • 7—BC sends the bitcoins to the user
• This is the normal scenario for many fixed-rate Bitcoin exchanges globally. But assume now that for some reason the BC receives thepayment notification 4 hours after the user transfers via the PP. Who is faulty? The User? The Bank? The Payment Provider? What if a similar payment problem happened for hundreds or thousands of payments over a period of days or weeks before the issue was identified and resolved? Who is “provably” liable for those loses/damages?
• With current techniques a manual auditing of logs would be necessary and would probably require legal authorizations. With Factom and the right audit applications, it would be trivial to detect where the problem came from, and also make the changing of records impossible post-issue. Basically, every system (BB, PP, BC) will publish their relevant traces in the secure broadcast channel (Factom) in real time.
• Here's another example of how Factom will be useful for Bitcoin exchanges audits. The so-called “Proof of Solvency” method for conducting Bitcoin exchange audits is a growing and important trend. However, there are significant weaknesses to this approach only solved by having the Factom secure broadcast channel functioning properly.
• In the Merkle tree approach for Solvency Proofs suggested by the Maxwell-Todd proposal, users must manually report that their balances (user's leaf) have been correctly incorporated in the liability declaration of the Financial Institution (FI) (the Merkle hash of the FI' s database of user balances). The proposed solution works if enough users verify that their account was included in the tree, and in a case where their account is not included, it's assumed that this instance would be reported. One potential risk with this process is that an exchange database owner could produce a hash that is not the true representation of the database at all; the exchange hashes an incomplete database which would reduce its apparent liabilities to customers, thereby making them appear solvent to a verifying party. Here are some scenarios where a fraudulent exchange could easily exclude accounts:
• • “Colluding Whales” Attack: There is evidence that large Bitcoin traders are operating on various exchanges and moving markets significantly. Such traders need to have capital reserves at the largest exchanges to quickly execute orders. Often, traders choose exchanges that they “trust”. In this way they can be assured that should a hack or liquidity issue arise, they have priority to get their money out first. In this case, the exchange and trader could collude to remove the whales account balance from the database before it's hashed. An exchange's top 10 whales could easily represent 5 to 20% of an exchanges liabilities, so colluding with just a few of them could have a significant impact.
  • “Site Manipulation” Attack: To date, each Proof of Solvency audit has reported (the hash tree) on the institution's website. This gives no guarantee at all to users, since a malicious exchange could publish different states/balances to different groups of users, or retroactively change the state. Thus it is fundamental to publish this data through Factom's secure broadcast channel, and publish it frequently.
• The second attack is obviously solved by using Factom, while the first is not so obvious. As this paper doesn't focus on the mechanics of exchanges audits, we won't delve in the nitty-gritty details. However, the basic concept is that by having frequent time-stamped copies of the exchanges database Merkle hash, one could detect the inclusion or exclusive of large balances before or after audits. Then, the auditor could simply look into those large inclusions or exclusions, manually. Remember, the trader will ultimately need to get his money on or off the exchange at some point, and that'll show up in either the bank history or the Bitcoin transfer history.
• There are established process for detecting such fraudulent tactics in the traditional audit industry; however, it all starts with having accurate, verifiable, immutable time-series of the information in question.
• Other examples are provided of attacks on Factom. The reader, for example, may be familiar with a denial of service from spam. Since Factom is an open system, any user can put Entries into almost any Chain. Bitcoin has a similar phenomenon. In order for an Application to reject those transactions, the Application would first need to download and process them. A large number of bogus Entries could slow down the initial processing of the Application's transactions. This threat is mitigated by an attacker needing to spend money (resources) to carry it out. This is similar to Adam Back's Hashcash solution to email spam.
• Audits are another useful tool against spam, if the application is willing to trade off security versus convenience. Auditors could post “ignore” lists on the same chain, or create their own audit chains with those lists. An auditor could use a profile chain to develop their reputation, which would also allow review by other auditors. If any auditor made a bad call, it would be easily verifiable and the record of it would be permanent. Some validity processing is gray, in the sense that opinions may vary. Solving that problem would be implementation specific.
• Another example is a sybil attack of the DHT. Distributed Hash Tables in general are particularly susceptible to sybil attacks. An attacker could create many peers which make it difficult for honest nodes to communicate. In a simplistic DHT architecture, attackers can isolate a required piece of data from honest nodes. Sybil attacks have been observed on the BitTorrent network routing table. The paper “Real-World Sybil Attacks in BitTorrent Mainline DHT” detail these attacks. Fighting this type of attack is an active topic in academic research. One mitigation technique uses complex lookup techniques to find honest nodes among the sybils, studied in “Sybil-resistant DHT routing”. Some sybil mitigation techniques rely on a web-of-trust by adding a social network to the routing table, as explored in “A Sybil-proof one-hop DHT”. Factom will rely on the latest academic and open-source research in this topic to secure its DHT.
• A dictionary attack is now discussed. In this case, the attacker runs through all the Chain Names deemed to be possible or desirable and creates their ChainIDs, and the hashes of those ChainIDs. Then they watch for someone trying to create those Chains. Now the attacker can front run on a match. Because on a match, they know the ChainID, so they can construct a proper, but malicious Entry of their own, create the proper Chain payment and submit it rather than the users payment. If the attacker gets ahead of the user, then they will win. The defense against a dictionary attack is to avoid common name spaces and to submit your payment to multiple, long standing nodes in the network. In Factom, the flexibility of defining the Chain namespace makes efforts to hog the namespace ineffective.
• Fraudulent servers are now discussed. All Entries in Factom require signatures from the users, or must match a hash that has been signed by the users. This means that fraudulent Federated servers in the Federation pool have very limited attacks they can make on the protocol. Invalid Entries do not validate, and upon broadcasting an invalid Entry, the honest Federated Servers will immediately broadcast a Server Fault Message (SFM) on the fraudulent server. If a majority detect a fault, the faulty server is removed. As long as the majority do not collude, then the protocol will remain honest. Any Federated server that failed detect the fault likewise risks losing its support from Factom users, and dropping from the Federated server pool.
• Federated servers can delay recording of Entry payments. But because Entry payments are submitted via a distributed set of Factom Nodes, delaying of Entry payments will be noted. Users may withdraw support from servers without reasonable performance compared to the rest of the network.
• Federated servers can delay the recording of Entries. Here the payment is accepted (generally by another server) fairly quickly. But for one reason or another, a Federated server refuses to record the Entry. In the next minute, responsibility for that Chain will shift to another server. As long as most servers are honest, the Entry will be recorded. Then the data over time will show that a server is delaying Entries. This will cause them potentially to lose support.
• Federated servers can at any point send false messages. The other Federated servers then would issue a SFR on the on the rogue server when those messages didn't make sense. A majority of the servers issuing an SFR would boot the rogue server, then the network would ignore their messages and not forward them on.
• Federated servers can refuse to accept valid Entry payment messages based on the public address, under the assumption that the public address is associated with some party. Again, assuming a majority of servers are honest, the payment will be accepted when the control shifts to an honest server. Furthermore, nodes watching will see the delay, and perhaps a pattern of delays, and support will be lost for the misbehaving servers.
• FIG. 60 illustrates timestamping into Bitcoin, according to exemplary embodiments. The Factom timestamping mechanism secures transaction in the blockchain. Factom data is timestamped and made irreversible by the Bitcoin network. A user's data is as secure as any other Bitcoin transaction, once published to the Bitcoin blockchain. A compact proof of publication is possible for any data entered into the Factom system.
• As this disclosure above explained, data is organized into block structures, the highest level being Directory Blocks, which are created using Merkle trees. Every 10 minutes, the data set is frozen and submitted to the Bitcoin network. Since Bitcoin has an unpredictable block time, there may be more or fewer than one Factom timestamp per Bitcoin block. Bitcoin internal header block times themselves have a fluid idea of time. They have a 2 hour possible drift from reality. Factom will provide its own internal timestamps, adhering with standard time systems.
• The user data ordering will be assigned when received at the Federated servers. Factom organizes the submitted Entry references into sets of blocks. The block time for Factom is ten minutes. On closing, the Federated Server network generates consensus and the Entries that are part of that block structure are timestamped to a minute within the block. As a general note, the data could have existed long before it was timestamped. An Application running on top of Factom could provide finer and more accurate timestamping services prior to Entries being recorded in Factom. The Factom timestamp only proves the data did not originate after the Factom timestamp.
• The Merkle root of the Directory Block is entered into the Bitcoin blockchain with a spending transaction. The spend includes an output with an OP_RETURN. We refer to this as “anchoring” the Directory Block to the Bitcoin blockchain. This method is the least damaging to the Bitcoin network of the various ways to timestamp data.
• Two possible alternatives to the OP_RETURN data in the blockchain is anchored to the P2Pool headers (as in chronobit) or in the Bitcoin block header coinbase. The P2Pool headers would require several hours of mining to find a block which satisfies the P2Pool rules, and the added complexity to the Factom protocol would not be worth the benefits. Including the Merkle root into the coinbase of a block would require cooperation with miners, above and beyond the transaction processing they are already doing. The coinbase entry would still need to have a crypto signature from the Factom system, so would not save on much space relative to a signed transaction.
• The first two bytes of the available40 in the anchor will be a designator tag (2 bytes with the value “Fa”). The Factom anchor (32 bytes) is concatenated onto the tag, then the block height is added (up to 6 bytes, allowing for >500,000 years). The designator tag indicates the transaction could be a Factom anchor. Other qualifiers are required, but the tag and Factom block height eliminates most of the OP_RETURN transactions that would otherwise need to be inspected. The block height in the OP_RETURN helps to fix the order in those cases where the Bitcoin blockchain records the anchors out of order.
• The anchored data is the Merkle root of list containing the Directory Block's Merkle root. Querying a database or DHT for the anchored data will return the Directory Block which can be used to find the rest of the data in the block. The Merkle root timestamp will be entered into the Bitcoin blockchain by one of the Federated servers. The server delegated to timestamp the federation's collected data creates a Bitcoin transaction. The transaction will be broadcast to the Bitcoin network, and be included in a Bitcoin block. Bitcoin transactions that look like a Factom anchor, but are not spent from an address known as a Factom server would either be junk, or an attempt to fork Factom. Most users/applications would ignore such anchors.
• Bitcoin blocks are generated with a statistical process, and as such their timing cannot be predicted. This means that the anchors are only roughly time-bound by the OP_RETURNs inserted into the Bitcoin blockchain, and its timestamping mechanism. The real value of anchoring Factom to Bitcoin is to prevent anyone from generating false Factom histories. Due to bad luck of Bitcoin miners, or delayed inclusion of Factom transactions, the time between when the Factom state is frozen for a particular 10 minute period and when the anchor appears in Bitcoin can vary, perhaps significantly.
• Now the ramifications of federated servers and anchoring verses proof of work is discussed. Proof of Work (PoW) is optimized for permissionless participation and validation of the historical record of a blockchain. The typical implementation of Proof of Work is to repeatedly hash blocks until one of the parties mining finds a hash with the difficulty required by the current requirements of a blockchain. This allows anyone to serve as a miner, to collect and validate transactions, pack them into blocks, and repeatedly hash that block looking for a solution that meets the difficulty requirement.
• The shortcomings of PoW have been widely discussed in the media as requiring unnecessary amounts of power, when other sorts of problem solving and work could result in benefits to blockchain users, the ecosystem, and society. Such is the goal of various Proof of Stake (PoS) systems used by various blockchains. But Proof of Stake alone makes the historical record hard to validate, and does not work well for a data recording system like Factom. This is because validating the historical Stake of parties involved the entire blockchain, and an understanding of the Stake that existed at each point in time historically. Factom needs small cryptographic proofs that validate sets of data, which PoW provides. Because PoW is validated solely by evaluating the difficulty of a hash.
• Anchoring is the solution Factom uses to secure the historical record, and at the same time avoid duplicating the massive expenditure of resources required of mining. A system like PoS can be used in the present, while anchoring secures the historical record. The idea of supporting parties allows permissionless participation in the Factom protocol beyond that of the Authority Set.
• The Authority Set and Anchoring means that running the Authority Servers is less expensive in resources by orders of magnitude compared to mining. Greater efficiency means that the rewards paid out by the Factom protocol can do more for the ecosystem than pay very large utility bills. Factom may use various voluntary but auditable methods to incentivize using the efficiency of the authority set to set aside resources within the protocol for productive real world work. A sort of Proof of Development could be used to receive these rewards using distributed support to identify work to be done, and evaluate the quality of the work that results. Such a system could provide rewards for development alongside the rewards generated for the authority set.
• A “Proof of Development” comes with its own issues. The main issue is the “Oracle Problem,” where it is very hard to know from within the programming of a blockchain protocol what might be useful development in the real-world and evaluate the quality of such development once it is done. Factom may develop mechanisms to incentivize supporting parties in the protocol to create evaluation processes, audit trails, and certifications at every stage of development to address the Oracle Problem, and allow a self-correcting process to manage a viable “Proof of Development” that is more productive and ecologically friendly than simply rewarding the burning of energy resources for security.
• The Factom protocol and system are now compared with other blockchain technologies. For example, Factom differs from Bitcoin and Sidechains. Factom is very different from Bitcoin, and in fact very different from any current cryptocurrency project. Cryptocurrencies like Bitcoin implement a strict, distributed method for the validation of transactions, where anyone can validate each transaction, and the validity of every input into a transaction can be verified. Because each transaction is authorized via cryptographic proof, no transaction can be forged. Each transaction can be checked for validity by verifying signatures of each transaction, and the miners hold each other accountable for only including valid transactions.
• The Bitcoin protocol is transactionally complete. In other words, the creation and distribution of Bitcoins through transactions is completely defined within the Bitcoin protocol. Transactions (which specify movement of bitcoin) and block discovery (which move bitcoin via mining fees and provide block rewards) are the only inputs into the Bitcoin Protocol, and nothing leaves the Bitcoin Protocol. In other words, the 21 million bitcoins that will ultimately exist will always and forever exist within the protocol. Pegged sidechains, when implemented, will provide additional movement of bitcoin value outside the blockchain, while the pegged value is in stasis in the blockchain.
• The sidechains proposal describes a solution to increase the scalability of Bitcoin by allowing value control to move off the blockchain and onto a sidechain. In the sidechain, many trades can occur. Later, a cryptographic proof (not all the transactions in between) can be recorded in the blockchain which moves the BTC out of stasis in Bitcoin. This proof would have to be available to the Bitcoin miners, but the bulk of the transaction data would be left behind in the sidechain.
• Factom is in some sense attempting to increase scalability, but not by enabling more value transactions, but by moving non-BTC transactions off blockchain. This would be transactions that are not primarily intended to transfer Bitcoin value. For example transactions could manage domain name registrations, log security camera footage, track the provenance for art work, and even establish the value of show horses by documenting their history. Some of these do not move a value at all, like transactions establishing a proof of publication.
• Sidechains and Factom are both trying to move transactions off the blockchain, but to achieve similar ends via completely different mechanisms. At some point, Factom may integrate with a Bitcoin sidechain in order to take advantage of the atomic swaps from BTC to Factoids.
• Factom is also different from other blockchain technologies. Many different groups are looking to find ways to leverage the Bitcoin approach for managing other sorts of transactions besides tracking bitcoin balances. For example, the trading of assets such as houses or cars can be done digitally using Bitcoin extensions. Even the trading of commodities such as precious metals, futures, or securities might be done via clever encoding and inserting of information into the Bitcoin blockchain. Efforts to expand Bitcoin to cover these kinds of trades include Colored Coins, Mastercoin, and Counterparty. Some developers choose to build their own cryptocurrency with a more flexible protocol that can handle trades beyond currency. These include Namecoin, Ripple, Ethereum, BitShares, NXT, and others. Open Transactions (OT) uses Cryptographic signatures, signed receipts and proof of balance for users (i.e., a user does not need the transaction history to prove their balance, just the last receipt). In this way, OT can provide the spend of centralized servers without the risk of a centralized server that can alter client balances. Factom is decentralized, and only records Entries. So Factom can record data that would not meet OT's rules. But Factom will not execute at the rate OT can initially. Factom is distributed, and we expect that some, but not all users will employ cryptographic techniques similar to OT with their records.
• The great advantage to an independent platform over trying to build upon Bitcoin is found in flexibility. The Bitcoin protocol isn't optimized to allow for recording of arbitrary pieces of data, so the “bookkeeping” necessary for non-Bitcoin type transactions isn't necessarily supported by Bitcoin. Furthermore, Bitcoin' s Proof of Work (PoW) based consensus method is not a “one size fits all” solution, given that some transactions must resolve much faster than10 minutes. Ripple and Open Transactions vastly speed up confirmation times by changing the consensus method.
• An Application built upon Factom seeks to gain the ability to track assets and implement contracts, by leveraging the blockchain directly. Instead of inserting transactions into the blockchain (viewed as “blockchain bloat” by many), Factom records its Entries within its own structures. At the base level, Factom records what Chains have had Entries added to Factom within the Directory Block time. Scanning these records, Applications can pick out the Chains in which they are interested. Factom records each Chain independently, so Applications can then pull the Chain data they need.
• Factom is organized in a way that minimizes connections between user Chains. A Chain in Factom can be validated without any of the information held in other, unrelated Chains. This minimizes the information a Factom user has to maintain to validate the Chains they are interested in.
• Now Factom Consensus Similarities and Differences from Proof of Stake are discussed. The policy and reward mechanism in Factom is similar to Proof of Stake (PoS). Factom differs from most PoS systems in that many subsets of user stake and/or contribution may be recognized. Individual categories of stake can be weighted against each other to further decentralized Factom. This is an attempt to make the servers answerable to the users actively using and contributing to the protocol. The individual users would delegate their support to a server. The Federated servers with the top numbers of support would be responsible for coming to consensus.
• Some with a deep understand of Bitcoin have recognized that pure PoS consensus mechanisms are fundamentally flawed. There are two attacks that make pure PoS unworkable. The problems are referred to as “Stake Grinding” and “Nothing at Stake”. Although Factom has PoS elements, it does not suffer from these problems.
• Stake grinding is a problem where an attacker with a sizable (say 10%), but not majority share can formulate false histories. From some point in history, they can costlessly fork the blockchain, choosing to reorder past transactions such that their stake is always selected to create the subsequent blocks. They would be able to present this alternate version of history as part of an attack to steal value by double spending. Bitcoin solves this problem by strongly linking the information domain, where computers make decisions, with the thermodynamic domain, where humans burn energy. Considerable resources are expended in the thermodynamic domain, and is provable in the information domain. Bitcoin makes forming false histories hugely expensive.
• Factom is unable to create alternate histories after the fact, since it is unable to insert transactions into historical Bitcoin blocks. It is also unable to create parallel histories without being detected, since Factom is linked to Bitcoin with known Bitcoin private keys.
• The Nothing at Stake problem is more subtle. With a policy disagreement in Bitcoin, miners must choose either one policy or the other. If they choose against the majority, they will be burning lots of electricity without a chance of recouping costs. PoS miners do not face this dilemma. They can hedge their bets and costlessly create forks complying with each side of the policy. They would simultaneously agree with both sides of the disagreement. This would open up the economy to double spend attacks. One of two merchants following different forks will ultimately have that money becomes worthless.
• Bitcoin solves this problem by having unintelligent unambiguous automatable rules for selecting the correct fork. In Bitcoin, the correct fork is the one with the most Proof of Work (PoW). Factom will also have unintelligent unambiguous automatable rules to select a correct fork, should one arise.
• FIG. 61 is a flowchart illustrating a method or algorithm for processing of thedigital contract20, according to exemplary embodiments. Thecontract identifier28, thecontractual parameter30, and/or thetable identifier334 is/are received (Block340). Thenetwork resource50 is identified (Block342), and the contract processor may be an IP address, URL, virtual machine, or other network destination representing a vendor, contractor, server, or service that executes the decision table326 and/or thedigital contract20. Theservice request266 is sent (Block344), theservice update270 is received (Block346), and theservice response268 is received (Block348). The data records70 in theblockchain data layer72 are generated (Block350), and the data records70 describe the execution of thedigital contract20. The data records70 may be hashed (Block352) and incorporated into the public blockchain24 (Block354).
• FIG. 62 is a schematic illustrating still more exemplary embodiments.FIG. 62 is a more detailed diagram illustrating a processor-controlleddevice360. As earlier paragraphs explained, the entity'sprivate software application40, thedata layer application154, and/or thecontract application302 may partially or entirely operate in any mobile or stationary processor-controlled device.FIG. 62, then, illustrates the entity'sprivate software application40, thedata layer application154, and/or thecontract application302 stored in a memory subsystem of the processor-controlleddevice360. One or more processors communicate with the memory subsystem and execute either, some, or all applications. Because the processor-controlleddevice360 is well known to those of ordinary skill in the art, no further explanation is needed.
• FIG. 63 depicts other possible operating environments for additional aspects of the exemplary embodiments.FIG. 63 illustrates the entity'sprivate software application40, thedata layer application154, and/or thecontract application302 operating within various other processor-controlleddevices360.FIG. 63, for example, illustrates that the entity'sprivate software application40, thedata layer application154, and/or thecontract application302 may entirely or partially operate within a smartphone362, a personal/digital video recorder (PVR/DVR)364, a Global Positioning System (GPS)device366, aninteractive television368, atablet computer370, or any computer system, communications device, or processor-controlled device utilizing any of the processors above described and/or a digital signal processor (DP/DSP)372. Moreover, the processor-controlleddevice360 may also include wearable devices (such as watches), radios, vehicle electronics, clocks, printers, gateways, mobile/implantable medical devices, and other apparatuses and systems. Because the architecture and operating principles of thevarious devices360 are well known, the hardware and software componentry of thevarious devices360 are not further shown and described.
• Exemplary embodiments may be applied to any signaling standard. Most readers are thought familiar with the Global System for Mobile (GSM) communications signaling standard. Those of ordinary skill in the art, however, also recognize that exemplary embodiments are equally applicable to any communications device utilizing the Time Division Multiple Access signaling standard, the Code Division Multiple Access signaling standard, the “dual-mode” GSM-ANSI Interoperability Team (GAIT) signaling standard, or any variant of the GSM/CDMA/TDMA signaling standard. Exemplary embodiments may also be applied to other standards, such as the I.E.E.E. 802 family of standards, the Industrial, Scientific, and Medical band of the electromagnetic spectrum, BLUETOOTH®, and any other.
• Exemplary embodiments may be physically embodied on or in a computer-readable storage medium. This computer-readable medium, for example, may include CD-ROM, DVD, tape, cassette, floppy disk, optical disk, memory card, memory drive, and large-capacity disks. This computer-readable medium, or media, could be distributed to end-subscribers, licensees, and assignees. A computer program product comprises processor-executable instructions for execution of digital contracts, as the above paragraphs explain.
• While the exemplary embodiments have been described with respect to various features, aspects, and embodiments, those skilled and unskilled in the art will recognize the exemplary embodiments are not so limited. Other variations, modifications, and alternative embodiments may be made without departing from the spirit and scope of the exemplary embodiments.

Claims (19)

1. A method performed by a server that records cryptographic transactions conducted by computers, the method comprising:

receiving, by the server, a cryptographic transaction of the cryptographic transactions;

determining, by the server, a chain identifier that is associated with the cryptographic transaction;

determining, by the server, an entry block in a blockchain data layer that is associated with the chain identifier;

adding, by the server, the cryptographic transaction to the entry block in the blockchain data layer that is associated with the chain identifier;

generating, by the server, a directory block in the blockchain data layer based on the entry block and the chain identifier; and

recording, by the server, the directory block to a blockchain;

wherein the directory block records the cryptographic transaction.

2. The method ofclaim 1, further comprising generating a hash value representing the directory block.

3. The method ofclaim 2, further comprising recording the hash value representing the directory block to the blockchain.

4. The method ofclaim 1, further comprising recording the chain identifier to the blockchain.

5. The method ofclaim 1, further comprising timestamping the cryptographic transaction.

6. The method ofclaim 1, further comprising timestamping the entry block. The method ofclaim 1, further comprising timestamping the directory block.

8. A system, comprising:

a hardware processor; and

a memory device storing instructions that when executed by the hardware processor perform operations, the operations comprising:

receiving a cryptographic transaction conducted by computers via a network;

determining a chain identifier that is associated with the cryptographic transaction;

determining an entry block in a blockchain data layer that is associated with the chain identifier;

adding the cryptographic transaction to the entry block in the blockchain data layer that is associated with the chain identifier;

generating a directory block in the blockchain data layer based on the entry block and the chain identifier; and

recording the directory block to a blockchain;

wherein the directory block records the cryptographic transaction.

9. The system ofclaim 8, wherein the operations further comprise generating a hash value representing the directory block.

10. The system ofclaim 9, wherein the operations further comprise recording the hash value representing the directory block to the blockchain.

11. The system ofclaim 8, wherein the operations further comprise recording the chain identifier to the blockchain.

12. The system ofclaim 8, wherein the operations further comprise timestamping the cryptographic transaction.

13. The system ofclaim 8, wherein the operations further comprise timestamping the entry block.

14. The system ofclaim 8, wherein the operations further comprise timestamping the directory block.

15. A memory device storing instructions that when executed by a hardware processor perform operations, the operations comprising:

receiving cryptographic transactions conducted by computers via a network;

determining a chain identifier that is associated with the cryptographic transactions;

determining a directory block that is associated with the chain identifier;

recording the cryptographic transactions to the directory block;

determining a rate of generation associated with the directory block;

identifying a virtual machine that is associated with the rate of generation; and

assigning the virtual machine to the cryptographic transactions.

16. The memory device ofclaim 15, wherein the operations further comprise hashing the directory block.

17. The memory device ofclaim 15, wherein the operations further comprise executing the virtual machine.

18. The memory device ofclaim 15, wherein the operations further comprise recording the virtual machine to a blockchain.

19. The memory device ofclaim 15, wherein the operations further comprise recording the cryptographic transactions to the blockchain.

20. The memory device ofclaim 15, wherein the operations further comprise recording the rate of generation to the blockchain.

Images