The JLINC Protocol is the interoperable solution for transparent crypto-contracts – cryptographically signed 'data exchange contracts'.
JLINC offers a simple elegant path to distributed Internet data control solutions, for everything from personal data in the EU, to B2B contract automation, to medical data, to binding IoT agreements (that inspire adoption), to data provenance in news, and eventually, distributed social network exchange.
The JLINC Protocol also delivers on the promise of 'smart contracts' in a safe, sensible, developer-friendly manner.
--JLINC lets two, or more, parties cryptographically sign automated data exchange contracts on the Internet, and exchange data between entirely separate domains under those contracts.
--Each party holds a mutually-signed copy of the contract and a signed record of every data transaction.
--A signed hash of each data transaction is recorded on an audit trail, recorded on all of the logs, ledgers or blockchains, specified by any of the parties.
--Standard contracts can be hosted by any 3rd party at a published URL.
--The contracts are both human and machine readable.
--Data exchange can be automated at a granular level between databases under the contracts.
This means that a company can use JLINC to automate existing contracts under existing law. In case of a dispute, a judge or arbiter can read the contract, and decide the case. The law remains the law. If there is an error in the code, the code can be corrected. This means that the code does not have to be perfectly error free (which is impossible). There is no black box containing the code that cannot be inspected. Therefore, those using it are not at risk of being defrauded, if someone successfully exploits an opportunity to introduce a hack into the code, or someone simply makes an error.
JLINC is built on a 'separation of concerns'. Each party holds their own copy of their own agreements on their own designated cloud. Standard APIs provide interoperable connectivity to end-user apps, while each organization can use any CRM or backend business process to connect to hosted JLINC cloud services. An enterprise can also run their own JLINC server in-house. Finally, the JLINC protocol itself is simple, elegant, and developer friendly, expressed in JSON using web tokens and standard PKI.
Much of the enthusiasm for blockchain stems from the perception that it represents a breakthrough for distributed, decentralized, solutions for Internet data exchange. We think so too. Indeed, one of the technological developments that inspired us to recognize that 'Internet link contracts' were finally possible was the advent of distributed ledgers. We built our first JLINC demo using Stellar Lumens, but then we ran into one of the fundamental errors with the current implementation of distributed ledgers; most make everything into a tokenized financial asset. For pure data transactions, that meant that the Stellar ledger was too expensive to use for pure data exchange contracts, even two years ago, when a Lumen was worth a tiny fraction of a cent and our data transaction credit was worth a tiny fraction of a Lumen.
Separation of the Metadata Transaction Layer
JLINC offers a standard universal developer-friendly inter-operable off-chain solution.
It provides the implementation layer that is actually needed to do much of the real work before an audit record is written to (multiple) blockchains, or a key lookup is performed on one, or many, blockchains. One could think of JLINC as the missing 'middleware' in many blockchain stacks.
By conflating the creation of data records with tokenized 'assets', many blockchains, and virtually all ICO's, have created an opportunity to bid up a bubble, but have created obstacles to simple sensible data flow models for most actual use-cases. Blockchain has captured the imagination of an enthusiastic community of coders, founders and investors, fueling rapid growth far ahead of demonstrated use-cases. Distributed ledgers clearly deliver some unique benefits, but are not a silver bullet.
JLINC actually solves a whole set of problems that many have expected blockchain to solve, except that it doesn't -- by itself. A blockchain, or distributed ledger, does one thing really well. It provides a distributed, (e.g. a not-centrally-controlled place) to look up publicly visible data. In general, distributed ledgers make crappy databases. They are slow and computationally expensive. They are also not a good place to record private agreements, nor private records, nor rapid complex transactions, nor many of the other things that people want to put on them now, along with the kitchen sink.
It’s also important to remember that each blockchain is effectively a silo. In most conversations about actual use-cases, there is a black box somewhere labeled 'off-chain-solution', which is assumed to be trivial, but which is almost invariably where the heavy lifting is done.
JLINC provides delegated 3rd party permissioning of data across multi-party chains. The actual agreements can be privately held, while reputation for one, or both parties, can be published on a ledger. This allows parties to both publicly, and privately, verify different aspects of data-provenance, across a distributed multi-party chain of custody. Each party maintains their own complete audit trail on whatever ledger or blockchain they specify.
Perhaps more importantly, for myriad actual use-cases where contract automation and multi-party agreements are necessary, a safe, efficient and secure method of signing and executing automated agreements is needed, which is exactly what JLINC actually provides.