In my recent articles I’ve been keeping it pretty general in order to make the concepts easier to communicate. But for this article were abandoning simplicity and diving into the details. So buckle up, get your tricorders out, it’s full on geek mode.

If you are curious about how Health Nexus and Ethereum are different this article is for you.

Health Nexus is based on the Ethereum blockchain; it’s a fork of it. There are a number of good reasons we picked Ethereum as a foundation instead of just using Ethereum (scalability, security etc) but what I want to discuss in this article is the nature of transactions on Ethereum and how we may change them for the healthcare industry.

Ethereum transactions and atomicity

Ethereum transactions are atomic, meaning they are comprised of indivisible components. This means that if any of their components fail, the whole thing fails. This done in other systems to make sure that there is an orderliness to the state represented by the data being stored.

A trivial example is booking a flight. There are at least two basic things you have to do: pay for your flight, and register your seat. If somehow the system let you do one without the other then someone is going to be extremely upset, so they make it so that if any of these operations fails they both fail.

In code this may look like this:

<Store some data here>

<Do some calculations on inputs here>

<Store more data here>

[Check to see if everything is good, if not: FAIL]

Note, the data was stored before the check. With atomic transaction we don’t have to worry about the data we changed before the check because as soon as the check fails all the modifications we made beforehand get undone. We call this reversion. It is expressed in solidity as the revert() command (instruction 0xfd ), or throw keyword.

To maintain data orderliness, this is brilliant — but combined with the transaction origin payment model the effect is that transactions are isolated and independent.

Who pays for transactions on Ethereum?

On Ethereum there is an origin payer model — the account originating the transaction pays for the gas needed to process that transaction. If they don’t have enough gas then that transaction fails. It’s simple. It works.

However, on Ethereum, if I wanted to create a transaction that did something I wanted it to do, and something you wanted it to do I would have to pay for both. Let’s checkout a practical healthcare example.

On Ethereum, if I wanted to log a change made to an off-chain medical record in my smart contract and you wanted to react to that by updating data in your smart contract not only would I have to tether my code to yours (expanding my transaction to include your code) but I would have to pay to run your code for you.

If I was super generous that would be fine, but because of atomicity, if something in your code failed it could cause my transaction to fail. I might be willing to pay for your stuff, but I’m not going to risk my transactions failing based on code I can’t control the quality of. The combination of atomicity and origin payer means that smart contracts are relatively isolated.

In Ethereum, if I wanted to respond to your transaction with a transaction of my own I would need an off-chain system to monitor the blockchain for the conditions I was interested in, and create independent transactions afterwards. There would be little visibility into that causal relationship because that relationship is established off-chain.

Molecular transactions and event driven decentralization

There are a number of modifications we are looking at for Health Nexus including integrating awareness of a distributed hash table (DHT — think decentralized file storage) onto the blockchain and enabling smart contracts to respond to data being stored on the DHT. To get there we need to do a few things. First we need to figure out who will pay for these transactions and how they will pay, then we need to create a protocol for establishing and handling on-chain relationships between transactions.

In this article it’s not my intent to discuss the implementation details of variable payer and event driven transactions. Rather, I want to highlight what emerges once you enable the combination of those, namely, molecular transactions.

Molecular transactions are individual atomic transaction that have a on-chain relationship.

Instead of hiding that causal relationship off-chain, transactions can directly cause additional transactions to take place. These related transactions have their own atomicity, but failure in them does not cause failure in the initial transaction. Moreover, these related transactions are payed for by the contracts that create them.

This enables a smart-contract environment that can be responsive to on-chain events in a trustless way; to us that seems like a good way to prove you are responsibly handling medical events.

There are many implications behind variable payer and event driven transactions (we have only begun to see the potential) and that’s just one of many ways Health Nexus will diverge from Ethereum as we create a blockchain for the healthcare industry.

For more information about Health Nexus checkout our whitepaper. To follow up with questions about Health Nexus or our token sale find us in our telegram group.

About SimplyVital Health:

SimplyVital Health is making decentralized technology accessible to the healthcare industry by creating Health Nexus, a healthcare-grade blockchain and paired data storage. Their principal application, ConnectingCare, augments existing hospital care systems to extract data and create care pathway flexibility, prospectively track financials, maintain immutable records, and accurately monitor analytics.

Website: https://tokensale.simplyvitalhealth.com/

News and Articles by us: https://medium.com/simplyvital