IOTA —The DAG-based IoT Network

IOTA takes a fundamentally different path to solve these problems than almost every other project. At their very base, blockchain networks are permissionless distributed ledger transaction networks, built in such a way that the record is immutable and no one server maintains all record-keeping and storage. As a consequence of being permissionless, anyone is free to send transactions on the network, which means anyone is free to attack the network, spamming it and clogging up memory on nodes and effectively crippling it. Most blockchain networks solve this by requiring transactions to have fees, making spam attacks cost more than they are worth.

The creators of IOTA, on the other hand, made it fee-less, so how do you make spamming the network costly? By requiring each device submitting a transaction to do a small but non-negligible amount of Proof-of-Work, by confirming other transactions. This has its drawbacks as transactions now take more computational work than any other fee-based, spam preventing transaction protocol, creating a group of IoT devices that are not powerful enough to work as intended while interacting with the IOTA network.

Being that IOTA is a DAG (Directed Acyclic Graph, Acyclic basically not linear like a blockchain), verified transactions in the network can be attached to many different “tips”, unlike blockchains where transaction history is wholly built upon previous blocks. Therefore, no blocks are ever generated and the verifying PoW for previous transactions is done by devices sending new transactions. So now the traditional mechanism for the slow infusion of new coins into the network is gone, which required the creators to create the entire supply upon genesis. This is not unlike many other Proof-of-Stake protocols but what sets this case apart is that with everything they did to make it feeless and fast, they have removed the core mechanisms and reasons for nodes to exist in the network.

Nodes are the bookkeepers and entry points to the network, required to serve as independent verifiers of history and passers-on of that which is sent to them. Without them, network-wide agreement on what is going on would be unachievable and transactions would never penetrate beyond your local devices. But nodes cost money to operate and therefore must be incentivized to participate in keeping a log and verifying actions. This is how statewide consensus with valid block creation reward (regardless of PoW or PoS) works. You create a system by which stability, security, and availability are rewarded with new coins, creating competition that feeds decentralization. IOTA’s base protocol disallows this. This is why they created the Coordinator.

The Coordinator, very basically, is an IOTA run node set up to help stabilize and increase the security of the IOTA network at the cost of centralization. Devices in the network, while they do verify transactions, they are no replacement for nodes in sharing transactions to other nodes to help transactions be seen by everyone, everywhere. While the Coordinator solved the stability issues, it limits the scalability of the network to just as fast as that one node can process and brings the whole network under a single point of failure. The plan was always to get rid of this once research had progressed to a solution and as of early this year, the plan to execute the Coordinator was announced.

Coordicide — IOTA’s Attempt at Decentralization

In PoW or PoS networks, nodes that secure the network are selected based on the scarce resources of computational power or stake. This ensures that transactional history cannot be reverted unless the attackers control a majority of that resource in the network, and the higher the value of that resource, the more expensive it is to attack.

Since transactions are validated by the devices sending the transactions, removing the need for miners in the network, computational power as a node selection criteria doesn't make sense. IOTA has chosen to create a secondary resource within the network for identifying node candidates: Mana. Mana is a reputation-based system where nodes and users can attach a node ID to a transaction to, in effect, “vote” for a given node. Each time a node ID is specified in a transaction, the Mana of that node is increased. The idea is that it is hard to gain mana but easy to lose it by acting improperly. The biggest problem with this protocol is that since transactions are fee-less, there is no real deterrent to spamming the network in order to vote for a given node.

This Mana will also be used as spam prevention in lieu of fees. Devices will be limited in the amount of transactions they can send by the PoW required to send the transactions, and nodes will be limited in the amount of transactions they can send to the network by the amount of Mana they have.

But there are two different ways to spam a network, high volume of lightweight transactions and low volume of heavy data transactions. One interesting byproduct of not having a required statewide consensus model is that subtangles can be created that act just like subchains with their own data structures and rules. This has great implications for IoT applications but also widens the attack vectors for spamming. So with this, you can send chunks of data instead of transactions, making that subtangle, not one of transfers of value but one of streams of data. This sounds great on the surface, and for very small amounts of data, this is. But even for slightly more complex IoT devices like a simple GPS position and velocity for an IoT vehicle will transmit at least 10 bytes of raw data with every update. Combined with the signature, this will likely be ~80 bytes. This data will probably need to be sent at least every 5 seconds in order to be useful, maybe more often. With a fleet of only 1,000 vehicles sending location and velocity data every 5 seconds, this subtangle will be growing at a rate of 1 Mb every minute, almost 1.5 Gb every day. For an IoT network of many devices and many data types and rates, nodes are going to become expensive to run and fast.

I see these causing problems in that new nodes with low Mana will not be able to contribute fully until they build enough reputation. Becoming a successful node will, therefore, be based more on time in the network than actual honesty or good performance.

The single biggest issue with this system is that influencing consensus is not dependent on any actually scarce resource. It is dependent on the amount of Mana a node has which is just dependent on how many times that node’s ID is referenced in a transaction that costs nothing to send.

They also plan to implement a tip selection algorithm by which the nodes can select the best DAG tips for transactions to build upon for the most stable and inclusive state. In the past, this was done in a random walk which often left good transactions behind creating the need for reattaching. This consensus protocol implements a voting mechanism to choose the best tip for which to build upon. The vote weight will be determined by the amount of Mana of the node much like a DPoS architecture. The tips with the most votes will determine the direction of the network and ensure that tangle is stable and every good transaction is included.

So to be clear, the direction of the tangle and state of consensus is based upon reputation which is based on the number of transactions that the node processes or transactions that reference it which are free to send. So it is absolutely certain this Mana will be built up by users spamming transactions.

So, what IOTA has had to create here in order to decentralize the network is a protocol by which nodes can be ranked by a “scarce” resource, that has endless supply, is free to create and is of no monetary value, to vote and collaborate with other nodes to determine the direction of the network (like gaining consensus on valid a block to build upon), to enable probable finality like Bitcoin in a stable-er network where your transactions are just less likely* to be never processed. And in all of this, no one seemed to ask, why would anyone run a node? There is no incentive, no block rewards, not even fees from transactions, and the Mana used to establish nodes isn’t a tradeable asset of any monetary value. And if a monetary incentive to be honest and reliable isn’t given, the benefit of running a node will be found at the expense of the honesty.

If the selfishness isn’t satisfied with a monetary reward how is it going to be satisfied? These nodes will likely be very expensive to outfit properly and build up enough Mana to be considered. So it is most likely that large corporations will be the ones operating nodes. What would incentivize them to operate a node if not for the money? By promoting the use of their IoT device and having direct access to the data transmitted.

Qubit — Smart Contracts and Oracles

But how is an IoT network ever going to be useful unless there is some way of automatically create actions within the network based on real-world data? That’s where Qubic comes in. Qubic is IOTAs answer to oracles and smart contracts.

In an effort to keep this article a readable length, I won’t go into much detail on Qubic because its a fairly simple idea (I know, not that simple) that several projects like ChainLink already do well, and there is not much information on IOTA’s implementation. Oracles work to take real-world data and put them in such a format that it can be useful in smart contracts within the network. I imagine the nodes of the IOTA network operating a qubic will be pulling in outside data and all nodes running qubics will vote on the validity and sign it creating a source of trusted data for smart contracts.

Since the IOTA transactional logic is not scripting enabled, smart contracts cannot be run on-chain and will, therefore, be stored and triggered within qubits. This is a great idea in that you will not need to pay gas to compensate for the computing of the contract on-chain, and instead, it is triggered node side off-chain. The only problem in doing so is you remove the public nature of on-chain contracts where you can see the code in its immutable state, published on the Blockchain and all transactions to and from. Iota might hide this from you and make smart contracts from manufacturers not open source.

My other concern with this is that the load of IoT transactions interacting with smart contracts will further push the requirements of the nodes operating qubits into the price points of only the well off or corporations with again, no talk of compensation. It is obvious to me again that information access is the commodity here.

So with all that said, how does INT’s approach to IoT compare to iotas?

INT — The Multichain Approach to IoT

INT takes the more traditional blockchain approach to spam prevention in creating a fee market for transactions where fees increase with transaction congestion, making attacking the network via spamming one that costs more than is to be gained. But more cleverly, INT employs a foundational architecture change to further disable congestion while enabling functionality.

INT employs a multichain framework pioneered by Polkadot to split the network into “cells” that can operate alone while still being able to seamlessly communicate with one another. By having the main chain handle all consensus and block generation, INT removes the requirement of nodes within the subchain to fully validate transactions, increasing throughput and freeing the subchain from the rigidity of the validation logic of the main chain. This allows each subchain to operate at 2,000 TPS with the ability to automatically scale with congestion. Increasing capacity is as simple as adding another subchain with nodes to support it. Said in another way, that is endless scaling to satisfy any IoT throughput needs.

By segregating traffic into cells within the network, any congestion happening within it doesn’t affect the network outside it. But more importantly for IoT, since subchains are separate from the main chain, they do not need to conform to the same transaction structure. So this means that if an IoT device requires fast, lightweight and free transactions, that can be done. If you need a blockchain that can encrypt, store and transfer complex data, it can be built within INT and have access to all data and assets within it. If an application on a subchain is getting bogged down with transactions, the rest of the network would not notice. No more Cryptokitties driving high tx fees for everyone else.

With this framework, one network can accommodate all IoT requirements while not having to compromise or generalize the blockchain.

But what about speed? IOTA’s DAG is touted for its speed in confirming transactions saying that they are practically instant. But, each transaction has to do the PoW verification before sending (which depending on the device, can take around .3 seconds) and then the speed after is dependent on the latency of the network. INT, on the other hand, is only dependent on the local latency as transaction verification happens node-side.

But even with its speed, IOTA transactions always carry the risk of being dropped or reverted as a consequence of the DAG and tip selection. Because of this, IOTA transactions are only probably final. INT on the other hand, with 13 validators operating a DBFT algorithm at 10 second block time gives us explicit finality in about 2.5 seconds. That means transactions are100% guaranteed to never be reverted 2.5 seconds after being included in a block. INT has recently released that their protocol improvements in node to node communication and block generation will allow the block frequency to be accelerated to 1 second in 4Q 2019, meaning finality will be reduced to ~0.3 seconds after being included in a block. This means AT WORST, transactions will be completely final within 2 seconds of it being sent based on latency.

So in the end, transactional speed between INT and IOTA will be negligible or equal with INT having the benefit of guaranteed inclusion in blocks and explicit finality.

How does one decentralize a network of this size and scope? INT is a DPoS network at its heart that uses its native coin, INT, to serve as it’s currency, stake and voting power within it. It is permissionless in that anyone can run a node and if they gather enough votes or stake for themselves, they will become a validator in the network. The top 100 registered nodes in the network build the peer node base, validating and gossiping transactions, with the top 13 nodes being the block creators and validators. These nodes are rewarded for the services and the security they provide the network with regular payouts based on the number of votes they have and the blocks they create. This incentivizes nodes, to be honest, and available as any disagreements or downtime equal lost reward.

They also employ an on-chain referendum system for voting on decision making within the INT foundation. This gives transparent power to the community of INT holders to control the direction of decision making.

But how does this promote decentralization or honesty from the nodes in power? The brilliance in this framework is that those in power are given power, for the most part, by the communities voting for them. So in a sense, the validation and direction of the network are answerable to those who hold INT. If you, as a node, is not serving the community or is acting in some dishonest way, you can be dethroned and another will replace you. This has led to a diverse and decentralized network in its current state with validators run by community members throughout Asia, Europe and USA with more than 138 million INT staked (36% of circulating supply).

INT Smart Contracts and Oracle

Again, no IoT network can be truly fully applicable without smart contracts or access to real-world data for decision making. INT is developing an on-chain smart contract architecture much like Ethereum’s EVM that will allow integration with those that are familiar with Solidity as well as other more common languages. They are also implementing WASM integration to greatly increase the efficiency of client-side execution.

This framework will allow subchains to be created to support specific device types and smart contracts, segregating congestion to the subchain without hampering throughput, using languages that are common, stored on-chain for transparency and openness, allowing the executing of code on local devices in the most efficient way possible. This is a better smart contract framework for protecting user data while maintaining the high throughput and efficiencies for IoT than the black box that will be Qubic.

Instead of reinventing what others are doing well, INT partnered with “a well-known oracle project” to inject real-world data into smart contracts. Oracles by their nature, are trusted sources of multisig’d data on outside events. By choosing to utilize an outside but well-known project, INT adds value to the oracle project, theoretically increasing the security of the data itself while ensuring no conflict of interest by not creating the data it is consuming. IOTA, in using their own oracle, create increased centralized trust within the network while adding the worry that they are creating the same data that they use for triggering their smart contracts. This may not turn out to be a bad thing as hopefully data between oracles agree, but it is something that might cause issues.

So when it comes down to the very base of it, INT and IOTA are just transactional bases with different data structures and approaches to preventing spam and incentivizing participation. IOTA, with it’s DAG, user-side PoW and lack of fees remove the usual mechanisms and reasons for decentralized nodes to exist. If you want someone to participate with their time and money, you need to incentivize it. Also, by storing data on the DAG and by creating innumerable subtangles for IoT applications, node requirements will get very costly, very quickly. These costly requirements with no monetary incentivization will inevitably result in manufacturers or other corporations running most of the nodes in the network, benefiting from direct access to device and personal data. INT, with its DBFT multichain blockchain, allows subchain creation based on a device’s or smart contract needs, allowing unlimited scaling, high throughput, and fast explicit finality. The DPoS node selection mechanism enables true permissionless decentralization which has already proven itself to be driven by the community and a referendum system to transparently involve the community in decision making. With changes coming later this year, any differences in the speed of transactions and confirmations will be nullified and the rest of the differences between INT and IOTA revolve around the execution of smart contracts and oracles and the centralization concerns mentioned earlier. It is for all these reasons (and many more) that I think users and IoT device manufacturers will be drawn to using INT as their IoT network.

If you want to read more about INT’s framework, other technological innovations utilized within INT or comparisons with other projects, check out more articles here.

*In essence, users are constantly building forks by connecting (and verifying with PoW) their transactions to previous transactions. The nodes in the network would then vote on the fork to make official. This means users can and will still build their transactions on discarded forks, meaning your transactions are still at risk of never verifying. In INT or other blockchains, if you have the ability to spend the input of your transaction, it will verify.