Ardor Blockchain Bootcamp Reviewed or: How I Learned to Stop Worrying and Master Ardor

Ardor

What a great feeling it is to challenge yourself and accomplish something that you have been meaning to do so for a long time. As an editor of Nxter for the past year, I have written much about the advanced functionality of Ardor and yet my dark secret until last week was that I had never truly explored the advanced functionality of Ardor. Sure I could parrot the concept of Phased Transactions but I have never created my own approval model. I could highlight the Asset Exchange functionality of child chains like Ignis, yet I have never issued my own asset or even bothered to see what assets are out there.

I acted like this guy:

But I really was like this:

I have that exact shirt!

But the plot twist here is that I decided to change all of this. I conquered my fear and my inadequacy and dammit I sat down and went to the Ardor Blockchain Bootcamp. Herein lies my review, and my experience.

SPOILER ALERT: the course is very well designed and has something to offer anyone, no matter their experience level and I highly recommend it to anyone who desires or wishes to be able to explore the advanced functionality of Ardor in a structured and guided manner. Yes, this course costs actual cash money, but I fervently believe that this course is a bargain for anyone who completes it as they are going to have a very solid understanding of many, but not all, of the functionality of the Ardor client.

 

What is Udemy?

For the uninitiated, Udemy is a website full of online courses, designed by knowledgeable and passionate people that are structured to teach you about specific courses. I needed to register an account with them to take this class.

Once I had passed the paywall I was in. It was comforting to read that this course ASSUMES NO PRIOR KNOWLEDGE. Nothing about Nxt, the Airdrop or anything like that. No special programming knowledge is required is plastered in the course description. While I personally enjoy programming, I get how the average plebian might be relieved to read this. This entire course is just using the Ardor client and the Ardor testnet. Oh yeah, I learned how to use the Ardor testnet too! #Exciting

 

Part 1: the Basics

The headphones are on, the calming lights are activated and I am ready to do this. The very first thing I am treated to is a calming video of the creator, Eric Funk, explaining to me what I am about to learn and what the objectives of this course are. I am excited to gain real-world, hands-on experience with the advanced features of Ardor.

What lies ahead of me is creating my own cryptocurrency, setting up my own poll using the Voting System, creating my own Asset on the Asset Exchange, issuing my own currency and more. I am actually knowledgeable about everything in part one, as is likely the average user. The first videos are likely very skippable for most Nxters – chances are that most everyone already has the Ardor client installed and an account created. No worries if this does not apply to you.

Like many Nxters my Ardor account is the same address as my Nxt account, but you know, with ARDOR prefixing it and not NXT. It was a little odd seeing an account creation process from scratch.

One thing that I heard that bears repeating, nay, tattooing onto your forehead, is that THERE IS NO CUSTOMER SUPPORT for Ardor. If you lose your PRIVATE KEY you have lost access to your account. This is the 21st century people – take some responsibility!

An interesting note is how US-centric these videos are. As our American audience knows, about the only real way to access the crypto world is through Coinbase. Oh, the horrors, the PTSD-like flashback of my account registration process with them last year. Shivers descend down my spine. Yet I persevere, I am not afraid. A critique I have is how hand-wavey the “Obtaining Ardor” video is for those who are truly beginners. The course recommends buying Bitcoin and converting it to ARDR on third-party exchanges. It reminded me of those cooking shows you see on TV: the host just magically has a pre-made version of the recipe just below the counter while you are struggling and making a mess of your kitchen trying to mix all the ingredients together. The video abstracts away A LOT of the frustration many users will experience as they try and convert fiat currency to crypto. Alas, us Americans do not have access to MisterTango accounts so the convenience of AEUR is unavailable to us. Regardless, the videos do a decent job of explaining how to fund your account with ARDR.

Now I am watching how to declare your public key by completing my first transaction. I want to nitpick how he does not explain the difference between Ardor, the blockchain, and ARDR the token of the blockchain. I am a perfectionist and such things bug me to no end. But again, I am here to learn and not to complain.

Overall the first part was very informative and complete – it exposes the core important concepts of blockchain without going into unnecessary detail. Simple and easy to follow along and all-in-all a pleasant experience. Videos around an hour.

Wow, an hour of my time has passed. I felt like I deserved something and so do you for reading this far. I present you with fuzzy kittens!

D’awww

 

Part 2: Advanced Placement

Part two of the course gets you down and dirty with the Ardor. For those only interested in trading crypto, Part 1 is enough. For those wishing to truly use and appreciate the future that is the blockchain, part two is for you. This is also where casual users of the Ardor platform can jump in and begin dabbling with the advanced functionality of the client.

Here I begin to explore the functionality of Ardor by using the Ardor testnet! Essentially I am using a real copy of the Ardor blockchain with FAKE tokens that have no real value. This way you can experiment without fear of losing tokens. From here on out the course takes place in the Ardor testnet in your browser and not in the Ardor client.

A shout out to Ardor.World – man this a great resource for anyone. In order to proceed in the course and become adroit at Ardor, I need to fund my testnet account. Luckily, you can get FREE testnet coins from the faucet links on the landing page!

It seems odd to me that FAKE testnet ARDR and IGNIS tokens are scarce – like why can I not have infinitely many fake ARDR tokens? I suspect that has something to do with how Ardor.world is set up. If I am wrong, please correct me in the comments.

Interesting to note that all the exercises for this section make use of the creator’s testnet accounts. There is no reason not to use your own, but I wanted to see if I could exactly use the same testnet accounts as Eric, the presenter, and I totally can. I feel like this does not scale with increased user activity, but hey, it works.

I finally get to experience conditional transactions. Not sure why they are called “Phased” transactions – I am ignorant of that distinction, I suspect it an esoteric computer science term. I created my first Approval Model and I saved it! Yet WTF am I limited to FIVE characters to naming things. Arbitrary limit is arbitrary, yo.

Random stock photo woman agrees with me

Continuing on now I am experiencing the Asset Exchange part of Ignis. I get it now, Ardor does not have an Asset Exchange. You and I cannot issue assets on Ardor but we can on Ignis because it is permissionless! That is sweet and totally makes sense now. This is coming from a guy who has written about this for a while now and yet it did not click until I actually created my own asset! The importance of asset control is mentioned many times here – the ability to control who can trade the asset.

Issuing assets and creating dividends is fun, it makes me feel like my own CEO. It is annoying how you need to search for assets by IDs so I hope you have handy the long string of numbers that represents the assets you wish to buy. A poorly optimized piece of UI for the Ardor client, but hey, it is what it is. Disclaimer, I understand that asset names are non-unique and that during the Ignis ICO there were many scammers out there selling assets named JLRDA. The only way to be sure you have the correct asset is by the asset ID. I just wish that there were a UI mechanism that would allow for verification of proper asset names such that I did not need to keep an ID string around.

I also get what Singleton assets are – nondivisible assets; like those absurdly popular crypto kitties on Ethereum.

Oh, for anyone who diligently does the exercises using the same testnet accounts you will need to copy and paste the passphrase like literally a million times.

Now for some real unknown waters for me: the Currency System. I have no idea how to create a currency, let alone do I know how they are different and distinct from assets. My understanding of Ardor continues to grow, as does my hair but that is not the point. The point is that I am deep in the course now, over two hours, and I am continuing to comprehend and appreciate the advanced features of Ardor.

Issuing my own currency is a little weird for me, but hey I can say that I have done it. The nuances of whether or not you want your issued currency to be “Reservable” and/or “Claimable” are subtle but powerful. Luckily the Ardor client (testnet and mainnet) are smart enough to not allow you to issue a currency with conditions that make it inoperable, but I sure wish that there was more documentation on what the significance of the categories are. I know the nxtwiki has documentation on this but it is not easy to grasp everything fully. It was fun to learn that, in essence, you can create “mineable” PoS coins and that you can enact conditions that only release the currency when they are fully met. There are many different currency types and different use cases for all of them. Admittedly this part was a little hard to follow.

The last few sections covered the many topics briefly. I created a poll whose only participants were the holders of my fake Ignis asset. Sweet – I see the usefulness of these polls. Why do I personally not use polls more often? Nxter needs polls – they drive engagement and are very easy to use. My only doubt is how can you link to them? This question is going to keep me up at night. But boy, are they useful!

The Data Cloud is cool, but documents are limited to 40K of space, good for hashes and code snippets. I understand that I can pay for more but man that seems small. Also, kudos to whoever listed Top Secret as a tag in the Data Cloud. I salute you, sir, or madam.

The Marketplace functionality of Ardor is great. I am guided through the Marketplace. The ability to list and sell things is great, but I wonder what guarantees I have of receiving the product? The same question exists on Craigslist and eBay but with them, the company can intervene on my behalf if a seller does not ship the product. On the testnet the products are fake – 5 IGNIS for a sailboat is too good to be true. LOL on whoever listed cocaine on the testnet Marketplace. The creativity and dark humor of people amuses me to no end.

Messages are the last section on my journey and it is mostly as advertised, but with an important distinction that I am probably the last person to appreciate: Shared Keys allow for third-parties to see encrypted messages to me without me giving up my Private Key/ Passphrase. That is a great point to understand and one that was here-to-before lost upon me – with them you can share sensitive data like identity documents, medical journals, certificates, whatever. Again, I am probably the last person to get this, but hey, better late than never!

And that is it, I put my headphones down. My 3.5-hour long journey is over. Before I was but a padawan, but now I am an advanced user! I am pumped and want to sell this exciting and exhilarating feeling of completing the course and gaining a much better understanding and intuition of the powerful functionality of Ardor.

I am no master of Ardor, but I am a sufficiently advanced user who now has the foundation to continue to explore and build my knowledge base. My journey is not over – it is only beginning.  It is a little deceptive to claim that anyone is a “Master” of Ardor after completing this course, but you definitely will be an advanced user.

The hands-on structure and constant manipulation of the Ardor testnet account were a great asset to me, and likely will be to anyone interested in exploring and mastering Ardor as well. A few minor gripes aside, (more on Forging and Bundlers please) and a complete lack of any mention to Lightweight Contracts, Multisig Transactions, and Cold Storage and proof-of account-ownership tokens, the course was engaging and methodical.

Nonetheless, believe that this course is very thorough and well-paced if not a little brief infrequently. The nuances of the many restrictions possible for currency and asset creation requires more of my time to fully appreciate all the different use cases for them.

Kudos to the creator for making this course. The material is accessible to all and well presented. The beauty of Udemy is that you do not need to watch every single video. You have access to all the content from the beginning and can immediately jump to the sections that interest you. Manipulating the exercises in Part 2 requires nothing from Part 1 if you already have the Ardor client installed and running.

The blockchain is the future people, experience it! Long series of sequentially hashed files are the future and now I am an advanced user of Ardor. I am prepared. My Private Key is secure, my high fives are for sale and I am ready to broadcast on Ardor, and to the world, that I am truly appreciative of the advanced blockchain features that are standard on Ardor.

Conclusion

I feel accomplished and I experienced, hands-on, much of the great functionality of Ardor. What are you afraid of when it comes to learning and personally exploring Ardor? Here, let me incline you to begin the same journey as me by offering this Nxter code course discount!

To many, a blockchain is a scary thing, an abstract concept that is hard to connect to. This is patently absurd – overcome your fear by practicing with it – it exists right now. Wonderful functionality already exists that is immediately usable for most anyone and this is just the beginning of what is to come!  There are many great features of Ardor: the Coin Exchange, the Monetary System, the Voting System, the ability to add conditions to transactions, Aliases, Currency creation, the Marketplace, all of it. But it is nothing more than words unless you experience it – dabble with it. Make it your own! With the release of this course, I believe that the time of being hesitant is over. Take the course and learn the advanced topics and concepts of Ardor. Now it is May and soon it will be June and then it will be summer and then you will be dead! Act now and learn the joys of using Ardor, you will be filled with regret of not taking a small amount of time to appreciate just how powerful a tool we have at our fingertips right now.

Ardor vs. the Competition, Closing Remarks

This is the final installment of a series of articles that compares Ardor to other blockchain projects with similar features or goals. You can find the rest of the series here:

Or you can download the complete series as a free ebook here: Ardor vs The Competition

This series started with a brief, informal reddit post with my initial reactions to the Plasma paper. I didn’t know at the time that it would launch me on a tour of half a dozen other cryptocurrency projects, ranging from sidechain platforms (Lisk, Stratis, arguably Komodo) to colored-coins platforms with unique features (NEM, Waves), to a project that eschews the blockchain altogether in favor of a completely different data structure (IOTA). Now that we have come full-circle, with the last two articles focusing once again on Ethereum, I think we have reached a good place to conclude.

This series has covered a lot of ground, and I won’t attempt to summarize everything here. Instead, I would like to share my thoughts on an overarching theme that emerged from my research on these projects.

Scaling Securely

As I’ve mentioned before, my primary interest throughout this series has been to survey various approaches to the difficult problem of scaling a blockchain. What I’ve learned is that there are many different strategies, but most involve a trade-off with security. I am certainly not the first one to make this observation, but I think it bears repeating here in the context of this series.

At one end of the spectrum, the most secure way to launch a new blockchain project is probably to issue a token on an existing blockchain that has already secured itself. This is the colored-coins approach that Nxt, NEM, Waves, and Ethereum use, for example. Transactions involving these tokens are recorded directly on the underlying blockchain and are therefore just as secure as any other transactions on it.

The obvious drawback of this approach is that it doesn’t scale particularly well: every node on the network must process all transactions involving all tokens on the blockchain, even if the projects that those tokens represent have nothing to do with one another. Moreover, all of this transaction data is stored forever on the same blockchain, bloating it at a rate proportional to the combined transaction volume of all of the projects running on it.

So-called “vertical” scaling methods, which aim to allow each node to do the same amount of work faster, or store the same amount of data more efficiently, are the natural way to scale this strategy. NEM’s Catapult project is a good example, as it focuses on optimizing the full client’s code and the communication protocol used on the network. Waves NG, an optimization of the forging protocol, is another example.

This approach to scaling ultimately runs into limits, though. At some point, adding enough users and transactions will break these designs, and the only viable option is some form of “horizontal” scaling, where each node on the network processes and stores only a subset of all transactions.

One reasonable way to scale a blockchain platform horizontally is to push each project onto its own independent blockchain, which is the approach that sidechain platforms like Lisk and Stratis are taking. This approach occupies the other end of the security-scalability spectrum: it naturally partitions both the total computational work and storage required to run the platform and allows different nodes to handle each partition, but this scaling comes at the cost of decreased security. Specifically, with N projects running on a sidechain platform, the weakest sidechain is secured by at most 1/N of the total miners or forgers, and likely far fewer than that, especially in its infancy.

Ardor partially transcends the security-scalability spectrum, successfully partitioning the storage of child chain data without sacrificing security. The price of this benefit is that the entire network must still process each transaction. It will be interesting to see the details of Jelurida’s plan to push child chain transaction processing onto dedicated subnets of the network, which would provide the missing computational and bandwidth scaling, but until then, we must refrain from speculating.

IOTA is a bit of a special case, as its design is fundamentally different from a blockchain in a couple of important ways. Without rehashing the whole mechanism of “eventual consensus” on the tangle, allow me to say that IOTA’s tangle (as it is implemented today) seems to me to be primarily a form of vertical scaling, with an element of horizontal scaling. Each node sees and stores every transaction, and although nodes can continuously prune the tangle over time, reducing the storage requirement, “permanodes” on the network must still store the entire history of the tangle in order to bootstrap new nodes trustlessly. On the other hand, nodes do not necessarily need to validate each transaction, as they can accept transactions that are sufficiently deep in the tangle as having been confirmed by other nodes on the network as long as they are referenced by all tips.

In other words, IOTA partitions the computational work required to validate transactions, but not the bandwidth required to relay them or the data that must be stored.

Eventually, IOTA plans to introduce “swarm” nodes to divide up the work of transaction validation and tangle storage. This will be a form of full horizontal partitioning, but I have not yet been able to find technical details, so in my opinion, it belongs in the same category as Ethereum’s Plasma and sharding proposals: a plausible-sounding idea that needs further development before it can be accepted as a real solution.

On that note, I’d like to make one final point about Ardor’s approach towards scaling: while it is not a panacea, at least at this early stage, it is important not to understate the value of an architecture that exists and actually works. Perhaps it goes without saying, but Ardor’s developers are not just hypothesizing about theoretical solutions to a difficult problem. They have proven that they can devise an ambitious but realistic design, implement it in a reasonable time frame, and in doing so make substantial, concrete progress towards a truly scalable blockchain. Not every team can make those claims, no matter how promising their initial ideas sound.

Final Thoughts

There is plenty more to be said about all of these projects, but this will have to suffice for now. I hope you’ve enjoyed reading these articles even half as much as I’ve enjoyed writing them. On a personal note, I would like to thank you for reading this far, and for sharing these articles with other blockchain enthusiasts. It has been immensely rewarding to see people offer their support, comments, critiques, and all manner of other reactions. I am humbled and deeply grateful that you took the time to engage with my work.

If I may leave you with a parting thought, it is this: after all is said and done, I see tremendous potential in several of these projects, but I am especially excited about Ardor. Its parent-chain/child-chain architecture simultaneously addresses two very important problems: how to cope with bloat, and how to offer a blockchain as a service to clients who do not have the resources or expertise to start their own blockchains. It is anybody’s guess what economic value markets will ultimately assign to Ardor’s solutions to these problems, but in my humble opinion, Ardor compares quite favorably to the competition on both points. I can’t wait to see what the future holds.


Try Ardor on testnet

About the latest Ardor testnet version

Ardor vs. the Competition, Pt. 8: Ethereum (Blockchain Bloat)

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

This article continues the previous installment’s comparison between Ardor and Ethereum. This time, I explore how each platform approaches the problem of blockchain bloat. To my surprise, the two platforms are more similar in this regard than I had initially thought, though there are certainly significant differences, too.

Key to this comparison is an understanding of how the Ethereum blockchain is organized.

Ethereum’s Structure

Like Nxt, Ethereum tracks the current state of all accounts with each new block. And like Bitcoin, Ethereum organizes the information in each block into a Merkle tree (actually, three of them) and stores its root hash in the block’s header.

How exactly does this work? The diagrams from this article help to illustrate.

 

The leaf nodes of a Merkle tree (i.e., those at the bottom) represent all of the actual data stored in it. Each node above the leaves stores a cryptographic hash of its two children. (Note that I’m using “node” here to refer to items in the tree, not computers on the network. Each computer on the network stores the entire tree.)

This design has the property that if even a single leaf node changes by a single byte, the hash of its parent changes as well, along with the hash of its parent’s parent, and so on all the way up to the topmost node, called the “Merkle root.” In a sense, the Merkle root contains a digest of all of the information in the leaf nodes.

Simply grouping all of the leaf nodes together and hashing them all at once would produce a similar result, but the tree structure has a second nice property, which is that it is possible to prove that a single leaf is in the tree without seeing the entire tree. For example, in this diagram it is possible to prove that the green transaction has been included by supplying its sibling, in yellow, their parent, in gray, and the other siblings and parents along the path back to the root. Another user can compute the relevant hashes at each level in the tree, then compare the resulting Merkle root to the one stored in the blockchain. These “Merkle proofs” are the foundation of Bitcoin’s simplified payment verification (SPV) clients, and also several of Ethereum’s scaling proposals.

Ethereum uses three separate Merkle trees to record the data in each block: one for the block’s transactions; a second for a set of “receipts” for those transactions, which represent each transaction’s effects; and a third for recording the instantaneous state of all accounts, including their balances and associated data. Storing the entire state of the system with every block sounds tremendously wasteful, but since each block modifies only a very small subset of leaf nodes, most branches of the state tree do not change from block to block, and each new state tree can refer to entire branches of the previous one with minimal overhead. There are a few technical complications with this approach, and for that reason Ethereum actually uses a slightly different data structure called a Merkle-Patricia tree, but the concept is the same.

Ethereum’s Fast-Sync Nodes

The most important fact in all of this is that the properties of cryptographic hash functions ensure that it is practically impossible to construct two different trees with the same root. As a result, the record of Merkle roots stored in Ethereum’s block headers is sufficient to establish that the network at the time validated the corresponding transactions and state transitions.

In other words, even after a node has “forgotten” the contents of old blocks, as long as it keeps the (much smaller) block headers in storage, it can query a full node for a given block’s contents and verify for itself that the full node has not tampered with any data. It does this simply by recomputing the relevant Merkle roots and comparing to the corresponding values in the block’s header. (Note that here and for the remainder of the article, I’ve switched back to using “node” to refer to a peer on the network, not an item in a Merkle tree.)

This approach is exactly how the Go Ethereum (geth) wallet’s fast-sync option works. To perform a fast-sync, a new node first downloads and verifies all block headers, starting with the genesis block (actually, only every 100th block header must be verified; see the GitHub link for details). Since the headers contain the proof-of-work, this step is sufficient to show that the network came to consensus about the Merkle roots in each header at the time the block was mined.

At some point in the recent past, say, 1024 blocks ago, the node gets a full version of the state tree from its peers and validates it against the Merkle root in the corresponding header. From that point forward, the node downloads full blocks from peers and replays all transactions until it has reached the most recent block, at which point it simply turns into an ordinary full node.

Although Go Ethereum does not currently support it, it is also possible for nodes to continuously prune the state tree as time progresses, keeping the amount of state data that must be stored to a minimum.

Child Chain Pruning on Ardor

If you have studied Ardor’s parent-chain/child-chain architecture, this strategy hopefully sounds quite familiar. Ardor takes a very similar approach with regards to its child chains.

Briefly, the Ardor platform consists of a single proof-of-stake parent chain, also called Ardor, and a set of child chains. The parent chain supports only a few transaction types, basically, just those required for transferring ARDR around and for forging with it. The child chains, in turn, handle all of the actual business conducted on the platform using the smart transactions I described in the previous article in this series.

Only the parent chain’s coin (ARDR) can be used to forge. Transactions involving only the child chains’ coins do not affect the balances of the forging coin, so they are not essential to the security of the blockchain and do not need to be stored permanently. Special “bundler” nodes on each child chain collect these transactions, group them together, hash them, and report the hash to the network using a special transaction type called ChildChainBlock. They include the full transaction data along with each ChildChainBlock transaction, so forgers and other nodes can verify that the child-chain transactions are valid and do indeed produce the reported hash, but the transaction data itself is not stored in the blockchain, and after a specified time passes it can be pruned away. All that remains in the parent blockchain is the hash of this data.

Optionally, special archival nodes on each child chain can store the full history of that child chain’s transactions. In cases where this history is needed, nodes can retrieve it, hash the original bundles of transactions, and verify that the hashes match the ones recorded on the blockchain.

Hopefully, the comparison to geth’s fast-sync option is clear at this point: in both cases, nodes do not need to store the vast majority of transaction data to be able to verify that the network approved of those transactions at the time they were made. On Ethereum, it is sufficient to verify the proof-of-work in the block headers and the accuracy of any given Merkle root to be able to trust the corresponding state tree. Ardor is slightly more complicated because it uses proof-of-stake for consensus, but storing the full record of ARDR transactions along with ChildChainBlock transactions ensures that nodes can verify, starting from the genesis block, that each block was forged by an eligible forger.

Comparing the Two Designs

At this point, I hope you agree with me that we can draw the following parallels between Ethereum and Ardor:

  • An Ethereum full node is similar to an Ardor node that also stores the full history of every child chain.
  • An Ethereum fast-sync node that continuously prunes the state tree is similar to an ordinary Ardor node, which stores the full parent chain but prunes away all child-chain data.
  • Ardor offers the ability to run a node that stores the entire parent blockchain, plus the archived transaction data for a single child chain. This option currently has no equivalent on Ethereum.

These analogies are not perfect, of course. Specifically, it is worth noting that Ethereum’s block headers are considerably smaller than full parent chain blocks on Ardor. I’ve also glossed over the mechanism that Ardor uses to track snapshots of the full state of the system and store hashes of those snapshots in the parent chain.

Still, I think this comparison is helpful. The third item in this list is especially interesting since it seems to be the biggest qualitative difference between the two designs. On Ardor, the ability to store each child chain’s transaction history in a separate set of archival nodes allows for a type of vertical partitioning of the blockchain database. Since each child chain likely supports a different business or project, partitioning the total set of all transactions along the lines defined by child chains seems like a natural choice. On Ethereum, perhaps the best analogy would be a design where a user could run a full node for a single project, like Golem, without having to simultaneously run full nodes for Augur and BAT and hundreds of other projects.

On that note, it strikes me that Ethereum’s Merkle trees might naturally accommodate such a design, where a “Golem full node” would search the full blockchain for all transactions involving GNT, store Merkle proofs for those transactions and state transitions permanently, and discard the remaining data. I admit I haven’t thought through the implications of this idea, though, so I won’t say much more about it here.

In any event, neither this hypothetical strategy for Ethereum, nor Ardor’s parent-chain/child-chain architecture, represents true sharding of the blockchain, since in both cases each node still must process all transactions from the whole network. These designs partition the storage, but not the bandwidth or computational power, required to run the blockchain. A proper scaling strategy must address all three bottlenecks.

Speaking of sharding…

Sharding

Ethereum’s long-term vision for on-chain scaling is sharding, a way of partitioning both the storage of data and the processing of transactions. The goal is for most nodes on the network to have to process transactions from only a single shard, freeing them from the burden of validating and storing transactions that affect only other shards.

I won’t even attempt to survey the Ethereum team’s proposals here, as this article is already getting long, but if you’re interested in this topic I strongly recommend their fantastic sharding FAQ on GitHub.

The reason I bring up sharding, though, is that Ardor’s developers have suggested that they are exploring ways to push child-chain transaction processing to dedicated subnets of the Ardor network. They have not offered technical details yet, and I’ll refrain from speculating here about how it might work, but to me, the idea certainly seems plausible.

If the devs can deliver on this idea, then the Ardor platform will look a lot like the “basic design of a sharded blockchain” described in the Ethereum team’s document. That section of the paper describes a set of “collator” (bundler) nodes charged with collecting (bundling) transactions from a single shard (child chain), validating them, and recording their hash in a “collation header” (ChildChainBlock transaction) on the main (parent) blockchain. “Super-full nodes” (current parent-chain nodes) would process all transactions from all shards; “top-level nodes” (future parent-chain nodes) would process only the main chain blocks, but not the full contents of all collations; and “single-shard nodes” (future child-chain nodes) would process all transactions on the main chain and a single shard.

Almost all of the complications arise from cross-shard communication, and as a result, this design works best when the shards are largely independent. As I mentioned above, Ardor’s child chains might naturally accomplish this kind of partitioning, with each chain supporting a separate project, where interactions between projects are allowed but still less common than transactions within a project.

Conclusion

At this early stage, these ideas are quite tentative, of course. But the possibilities are exciting nonetheless. Ardor’s design already incorporates proof-of-stake consensus, a separate goal that the Ethereum team has set for itself, and a reasonable partitioning of the blockchain’s data, which is an obvious requirement for any sharded solution. Notably absent in Ardor are Merkle proofs, or some other compact way for partitions to trustlessly communicate state information to one another, but it does seem like these features could be built into the platform via a hard fork. The snapshot hashes and child-chain block hashes that would become Merkle roots are already present in the protocol, after all.

But what can we say about the current state of the two projects? Perhaps the most interesting fact I learned in researching and writing this article is that Ethereum actually scales far better than I had originally thought. Go Ethereum’s fast-sync option for full nodes affords some of the same advantages of Ardor’s design, and if it eventually incorporates state-tree pruning the analogy will be even closer.

On the other hand, the main drawback of Ethereum’s current design is that there must still be full nodes somewhere on the network, and those nodes must store all 300+ GB of the Ethereum blockchain. As it continues to grow, and the cost of running a full node grows along with it, one would expect the proportion of full nodes relative to fast-sync and light nodes to naturally decline. As a consequence, each full node will likely end up handling an increasing volume of requests from other nodes, further increasing the cost (in terms of bandwidth and computational power) of running a full node.

Even without sharding, Ardor’s design mitigates this potential problem by breaking Ethereum’s monolithic full nodes into sets of archival nodes that each store the current state of only one child chain. It will be possible to store the histories of several child chains simultaneously, if desired, but few nodes, or potentially none at all, will be required to store the full history of the entire system.

Needless to say, scaling a blockchain is a hard problem. Out of the several projects that I have surveyed for this series, Ardor and Ethereum seem to me to offer the most compelling visions for on-chain scaling. And while I am hopeful that both will succeed, I must admit that, judging solely from the concrete progress that each project has already made towards achieving its vision, Ardor seems to me to have an ever-so-slight head start.


Try Ardor on testnet

About the latest Ardor testnet version

 

 

Ardor vs. the Competition, Pt. 7: Ethereum (Smart Contracts)

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

This week I studied Ethereum, which probably needs no introduction.

For several of the projects I’ve surveyed throughout this series, it has been rather difficult to find detailed, technical information. Ethereum has exactly the opposite problem: there is so much information available that it is difficult to distill it into a reasonable-length article without oversimplifying important ideas.

For this reason, I have chosen only two aspects of Ethereum to compare to Ardor. This installment compares its smart contracts to Ardor’s smart transactions, and the next article will compare the approaches that the two platforms take to managing blockchain bloat. There are many more topics I would have liked to cover–its plans to move to Proof-of-Stake (Casper), its state-channel strategies (Raiden and Plasma), its partnerships with large companies through the Enterprise Ethereum Alliance, and a sampling of the projects running on it, for example–but discussing even a couple of these topics in satisfactory depth is a daunting enough task. Besides, the two topics I chose offer the most interesting comparisons between the two platforms, in my opinion (but see the Ardor vs. Plasma post, linked above, for some thoughts on Plasma).

Without further ado, let’s talk about smart contracts.

Smart Contracts and “Rich Statefulness”

Ethereum’s design combines elements of Bitcoin and Nxt, and adds several novel features. Like Bitcoin, Ethereum uses a low-level scripting language to encode transactions, and it stores the contents of each block in Merkle trees whose root hashes are recorded in the block headers (more on this in the next article). And like Nxt, it tracks the current state of account balances and other account-specific data directly instead of using Bitcoin’s unspent transaction output (UTXO) model.

The most important innovations that Ethereum adds to this mixture are twofold: the ability to store scripts (contracts) in so-called “contract accounts,” which transact autonomously instead of being controlled by a user; and the ability to persist data in an account from one transaction to the next. Ethereum’s scripting language is also somewhat more powerful than Bitcoin’s language, allowing contracts to include loops and to invoke other contracts.

Combining these ideas, it is possible to create stateful “smart contracts,” which are bits of code and data that live in contract accounts and act as autonomous agents, listening for input from users and other contracts and transacting with them according to the rules defined in their contract code. The “stateful” modifier in the previous sentence is crucial: because a smart contract can have its own internal state, it is possible for one transaction to affect how subsequent transactions are processed. This is a significant departure from Bitcoin’s model, where transaction scripts only execute a single time and where the notion of the “state” available to a script is essentially limited to whether a given output is spent or unspent.

(You might have noticed that I haven’t said anything about Turing completeness. Depending on how pedantic you’re feeling, you could argue either side of the question of whether Ethereum’s scripting language is actually Turing complete. As the speaker in this excellent video explains, though, Turing completeness is a bit of a red herring anyway. Much more important is the fact that smart contracts are stateful and can transact with one another and with users in interesting ways.)

The potential applications of smart contracts extend far beyond setting conditions on the transfer of money from one account to another. Even the original white paper (which is a great read, by the way) proposed a handful of non-financial uses, including file storage, voting, distributed computing, governance of decentralized organizations, and decentralized marketplaces. Since then, developers have found plenty of other applications, too, such as decentralized messaging. And of course, the most common application of Ethereum so far, seemingly by an overwhelming margin, has been to conduct token sales for various projects.

Ardor’s “Smart Transactions”

If that list of applications sounds familiar, it might be because all but one of them have already been implemented in Nxt and Ardor as prepackaged “smart transactions.” Pioneered by Ardor’s predecessor, Nxt, smart transactions are bits of “blockchain 2.0” functionality that the Nxt and Ardor developers have made available as part of the protocol itself. They allow developers to create blockchain applications without having to write and test their own smart contracts.

In order to enable ordinary users (i.e., non-developers) to take advantage of this functionality, too, the official Nxt and Ardor wallets include a handful of features built from smart transactions. These include:

  • the Asset Exchange, where users can issue assets, trade them, and pay dividends to asset holders;
  • the Monetary System, where users can issue currencies and conduct several different types of crowdfunding campaigns;
  • a messaging system, which allows users to send each other plain-text or encrypted messages;
  • a voting system, which allows users to conduct polls by account, account balance, asset balance, or currency balance;
  • an integrated coin shuffler, which can afford users a degree of privacy by obscuring their transaction histories;
  • a decentralized data store, which can record the hash of a file permanently on the blockchain and, optionally, record the file itself permanently in special archival nodes;
  • a decentralized marketplace, where users can buy and sell goods and services peer-to-peer;
  • a new Coin Exchange (Ardor only), where users can trade child-chain coins directly for one another; and,
  • a number of advanced features, such as phased transactions, which allow users to set constraints on when and how other transactions are executed, and account properties, which can be used to associate arbitrary data with an account.

These are not the only applications that can be built from smart transactions, of course, but they do illustrate the breadth of what can be achieved with them. All of these features, plus a few more, will be available on Ignis, Ardor’s first child chain. Creators of other child chains will have the option to implement as many of these features as needed to suit their projects.

I’ve heard several analogies to describe smart transactions, but my favorite is that they are like Legos, while smart contracts are like clay: the former don’t provide the same degree of control over the finer details, but they are quicker and easier to use than the latter, and can still be combined to form some quite impressive final products.

The analogy isn’t perfect, of course. A strong argument for smart contracts is that it is possible for potentially all of the business logic of a decentralized application (Dapp) to be recorded permanently and immutably on the blockchain, for example, whereas a Dapp built from a combination of smart transactions likely includes some external code. In the latter case, using the Dapp might require some degree of trust in the developer not to change the rules in later versions of it.

Viewed from another angle, though, this comparison hints at arguably the biggest drawback of smart contracts: the ease with which they allow programmers to make multimillion-dollar mistakes that cannot be corrected.

Security Considerations

Just about all software that is even modestly complex contains flaws, and too often these flaws make the software vulnerable to exploitation by an attacker. Smart contract developers face a particularly difficult task because the code they write is immutable, and as a result its vulnerabilities are permanent.

Unfortunately, catastrophic failures of buggy smart contracts have not been rare. The attack that froze $150 M worth of ether stored in multisig Parity wallets and the $30 M hack of that same wallet several months prior are the most recent examples to grab headlines, but they are not the first and almost certainly not the last. For an overview of some common vulnerabilities and analysis of several real attacks, including the infamous DAO hack, I strongly recommend this excellent paper by three researchers from the University of Cagliari.

It is worth noting that the Ethereum protocol and the Ethereum Virtual Machine (EVM) were not responsible for any of these attacks. Ethereum’s supporters sometimes point this out, arguing that Ethereum itself is quite secure, and all that is needed is for developers to write better smart contracts. In a literal sense they’re right, of course: in all cases, Ethereum did what it was supposed to do, and ultimately the blame lies with smart contract developers.

But personally, I wonder whether this assessment is too quick to absolve Ethereum, and whether the problem might run a bit deeper than just a few buggy smart contracts. For now, anyway, it seems to me that Ethereum’s fundamental predicament is that it gives programmers tremendous power, but insufficient tools to use that power safely.

Developers’ ambitions almost always exceed the level of complexity that they can achieve while keeping their code perfectly bug-free, and there will therefore be a constant temptation to make functionality a higher priority than security (this is nearly universal in software development, by the way). Immortalizing the buggy code that they produce by storing it in the blockchain, Ethereum brutally and mercilessly holds them to account for their sins.

Thankfully, there are certainly ways to mitigate the risk of writing vulnerable smart contracts. For example, it is possible to design a smart contract that can be updated by having it delegate its responsibilities to a second contract, commonly called a “library contract,” at an address that can be changed to point to a different library contract later.

This approach allows developers to patch vulnerabilities, but as a consequence, it introduces the thorny question of who is allowed to switch to a new library contract. If it is a single third-party account, then the design reintroduces some degree of trust between that account and users. On the other hand, if the developers take another approach, such as allowing a majority of users to vote in order to approve each new library contract, then there are potentially further problems to solve, such as writing a secure voting mechanism, making sure that users are sufficiently informed and engaged to vote, and preventing an attacker from doing significant damage in the time it takes to organize a vote.

Another very promising approach towards securing smart contracts is to use techniques of formal verification borrowed from mathematics. I do not know much about formal methods, so please take what I write here with a grain of salt, but I do know that it is easiest (or indeed, feasible at all) with simple programs whose proper functioning can be expressed as a set of short, simple rules. In such cases, it can be possible to prove with certainty that the program contains no bugs. Even straightforward techniques like looping and recursion can complicate the analysis significantly, though, so it is best if the program under test is as simple as possible.

Why am I droning on and on about all this? Putting these thoughts together, it would seem that the best way to write smart contracts might involve: 1) keeping them as short and as simple as possible; 2) delegating the core business logic to library contracts that can be updated if necessary; and 3) reusing libraries that have been thoroughly vetted, so as to keep the amount of new code to a minimum. If the second of these points requires that users trust the contract’s author to some degree, as is often the case, then contracts designed according to these three guidelines start to look a lot like Ardor’s smart transactions: bits of stable, thoroughly tested code that expose the most commonly needed functionality, which developers can assemble into more complex programs.

Trade-offs between Security and Flexibility

I am not suggesting that Ardor’s smart transactions can accomplish all of what Ethereum’s smart contracts can securely accomplish, nor am I even arguing that combinations of smart transactions can always emulate smart contracts. What I am saying, though, is that I think there is a natural tension between the flexibility that a platform offers and the security of the code that developers inevitably write for it.

In this view, blockchain platforms can be located on a security-flexibility continuum. Near the “security” extreme is Bitcoin, whose scripting language is deliberately quite limited in order to prevent users from locking their coins with vulnerable scripts (though this is still possible, of course). Nxt and Ardor occupy a position somewhere toward the middle of the spectrum, limiting developers to a set of predefined transaction types but including an awful lot of functionality in those types.

Ethereum’s smart contracts, on the other hand, occupy the entire spectrum. It is possible to write extremely simple, trivially secure scripts on Ethereum, and it is also possible to write more complicated scripts that contain very subtle vulnerabilities. Perhaps just as importantly, it is difficult for users to tell the difference between these cases–and unreasonable, in any event, to expect them to try. Using Ethereum safely necessarily means avoiding the “flexibility” end of the spectrum, even if it comes at the cost of introducing some extra trust between users and developers.

Finally, it is worth mentioning that Ardor offers a new feature, not previously available in Nxt, that helps it inch towards the “flexibility” end of the continuum: the ability to combine phasing conditions using Boolean AND, OR, and NOT operators to achieve primitive smart-contract-like behavior.

Briefly, phased transactions allow users to condition an underlying transaction on some event, such as approval by a certain number of specific accounts (m-of-n multisig), a vote by accounts holding a particular asset, the expiration of some amount of time (timelock), or the revelation of a secret (e.g., a hashlock). On Ardor, combinations of these phasing types can encode more complex conditions, such as, “transaction X is valid if a majority of ABC Corp.’s asset holders approve of it by date Y, unless it is vetoed by a supermajority of ABC Corp.’s board members.”

It will no doubt be possible to combine phasing conditions in ways that allow for unexpected outcomes, possibly including theft or loss of funds. But the advantage over smart contracts in terms of security is still there, I would argue, since developers can focus on making sure the business logic of the transaction is sound, without having to worry about low-level bugs like race conditions. And of course, the drawback of offering less flexibility than a smart contract is still there, too.

Conclusion

With a protocol defined by a set of prepackaged smart transactions instead of a low-level scripting language, Ardor will probably never be able to offer developers as wide a range of possibilities as Ethereum does, at least in cases where everything must be done on-chain for minimal trust between parties. On the other hand, writing nontrivial contracts that follow security best practices might well require additional trust between users and developers anyway. And of course, Ethereum users ultimately have to trust the authors of smart contracts not to have made any mistakes and to have duly scrutinized and tested their code in order to make sure of it.

Naturally, you might say the same thing about any software, including Ardor’s smart transactions, but there is a key difference: there is simply so much more code running on Ethereum. Nxt has been open-source since its inception, providing ample opportunity for peer review, and Ardor’s code, which builds on the Nxt codebase, will be opened soon. Moreover, each new change to the protocol has been vetted thoroughly on a public testnet before being officially released. The same ought to be true of each and every smart contract, but with so much code being written, it seems like there are inevitably more opportunities for bugs to slip through into production.

In any event, I suspect that the degree to which most successful Dapps will rely on immutable code is still an open question. If access to an immutable database and a handful of simple operations on that data are sufficient for most applications, then Ardor’s smart transactions seem to me to have an obvious advantage over smart contracts. If, in contrast, the notion that “code is law” turns out to be essential to the viability of most Dapps, with each Dapp requiring most of its unique code to be recorded on the blockchain in order to be truly trustless, then Ethereum’s approach is probably superior.

I expect that there will be real-world applications that suit each platform. But I also wonder whether it will eventually become clear that one of the two approaches best handles a sizable majority of applications. Which approach will ultimately “win” is not at all clear to me, but I suspect that the deciding factor will be users’ judgments of the degree of trust that each case requires. And since the entire appeal of blockchain technology is that it allows users to transact with minimal trust, I’d say that outcome would be quite appropriate.

Thanks for reading! If you enjoyed this article, be sure to read the next part of the series, which compares the ways that Ardor and Ethereum cope with blockchain bloat.


Try Ardor on testnet

About the latest Ardor testnet version

Ardor vs. the Competition, Pt. 6: Komodo/SuperNET

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

This week I studied Komodo, the blockchain platform that forms the basis of SuperNET.

SuperNET

Like Waves, SuperNET was founded by someone who was quite active in the Nxt community in the past. And as with my article about Waves, I won’t attempt to rehash that history here.

Suffice it to say that James/jl777 was the developer behind SuperNET, the Multigateway, and several other projects on Nxt, including a number of assets on the Nxt Asset Exchange, but he left the Nxt community during the turbulent period of late 2015 and early 2016. Since then, he has created the Komodo platform, which now serves as the foundation of SuperNET.

The vision of SuperNET is to enable users to seamlessly transact with many different cryptocurrencies in order to enjoy the unique advantages of each coin. The experience is to be so seamless, in fact, that the user might not even realize that he or she is using multiple coins. For example, if I understand correctly, a SuperNET application might allow users to transact privately with Bitcoin by converting to and from a privacy coin like Komodo behind the scenes. From a user’s perspective, it would be as if Bitcoin had “borrowed” Komodo’s privacy feature.

SuperNET isn’t itself a blockchain. Rather, it is a framework comprising several parts. The main ones are:

  1. Komodo, a blockchain anchored to Bitcoin;
  2. assetchains and geckochains, independent blockchains anchored to Komodo;
  3. the Agama wallet, a multicoin wallet;
  4. BarterDEX, a decentralized exchange (DEX) that will be integrated into the Agama wallet; and,
  5. Iguana, the codebase that underlies the Agama wallet and part of Komodo.

Note that much of the literature about SuperNET refers to the Agama wallet as the “Iguana wallet,” which was its previous name.

The “anchoring” process in items 1 and 2 is Komodo’s delayed proof-of-work consensus algorithm, which I describe next. I’ll return to BarterDEX later.

Delayed Proof of Work

Komodo is a fork of zCash, which is a blockchain that uses zero-knowledge proofs (via zk-SNARKs) to allow users to transact without publicly revealing their account numbers or the amounts that they exchange. Komodo has added several features to its branch of the zCash codebase, including the delayed proof-of-work (dPoW) consensus algorithm and a mechanism for creating additional blockchains that are periodically anchored to the Komodo chain.

The dPoW white paper argues that the dPoW mechanism allows any blockchain to secure itself using Bitcoin’s hashpower by periodically notarizing itself to Bitcoin. In a nutshell, consensus on the weaker blockchain occurs in two stages: an initial consensus by normal means (e.g., PoW or PoS), and a second layer of consensus established periodically by a set of notary nodes, elected by stakeholders, that record a hash of the weaker chain’s most recent block on the Bitcoin blockchain. All nodes on the network agree that, in the event of a fork, they will not reorganize the blockchain past the last time it was notarized on Bitcoin.

In this way, the author argues, the weaker blockchain inherits some of the security of Bitcoin. Even an attacker with a large majority of the network’s hashpower won’t be able to modify the blockchain back past the most recently notarized block. Accordingly, somebody who waits for a transaction on the weaker chain to be notarized on Bitcoin can be confident that it won’t be reversed.

The white paper also proposes a mechanism to allow the network to fall back to the initial consensus mechanism in the event that the notary nodes become unavailable. The idea is that all nodes on the network are eligible to mine, but the notary nodes are assigned a lower difficulty level than normal nodes. As a result, notary nodes will normally win most or all blocks, but if an attacker were to somehow take them offline–by a DDoS attack, for example–normal nodes would be able to continue mining blocks and the blockchain would continue uninterrupted, except without the added security of Bitcoin. In this way, the dPoW chain is somewhat less centralized than it appears at first blush.

This line of reasoning does beg the question of exactly what is gained by the notarization mechanism, though. In particular, if an attacker can gain control of the notary nodes, he can prevent them from signing the Bitcoin transactions that notarize the weaker chain’s blocks, forcing the weaker blockchain to rely only on its initial consensus. So it appears that the extra security provided by the notarization process depends implicitly on an honest majority of notary nodes.

[EDIT: After talking with jl777, I learned that Komodo allows a minority of notaries, 13 out of 64, to sign each notarizing transaction. This simultaneously reduces the Bitcoin fees that must be paid and makes the proposed attack harder, since an attacker would have to control a supermajority of notaries to defeat the notarization mechanism. My original statements were based off of what he wrote in the dPoW white paper, which suggests that 33 of the 64 notaries must sign the notarizing transactions.]

This is basically the security model of delegated proof-of-stake (DPOS) blockchains like BitShares. In both dPoW and DPOS, users vote by stake for a set of “special” accounts that the rest of the network depends upon for its security. Both systems suffer the same weaknesses, too: a burden on users to keep up with the “politics” of the system to know which accounts are trustworthy enough to vote for, and the corresponding voter apathy that this burden produces.

All things considered, I’m not sure I see a strong case for dPoW over and above other alternatives. If the weaker chain’s initial consensus mechanism is strong enough to secure it, given its current economic value, then paying Bitcoin fees to notarize it seems like a waste of money. If the initial consensus is not sufficient, on the other hand, then it seems that the security of the chain rests entirely on the election of honest notaries. But in that case, why not use DPOS and take advantage of the increased transaction throughput that DPOS chains have achieved?

Setting these considerations aside, though, it is worth noting that the Komodo platform uses nested dPoW chains to help achieve SuperNET’s vision of interconnecting a variety of different blockchains. Komodo’s additional chains are called “assetchains” and “geckochains”. These chains notarize themselves to Komodo, which in turn notarizes itself to Bitcoin. Again, the claim is that all chains involved inherit the level of security of Bitcoin, but as described above, a lot depends on each chain’s notary nodes.

Unlike assets on Nxt and Ardor, or even child chains on Ardor, Komodo’s assetchains are fully independent blockchains. Their only connection to the Komodo chain is the dPoW notarization mechanism. In this way, they are perhaps closer to the sidechains that Lisk and Stratis envision than they are to Ardor’s tightly-coupled child chains.

Geckochains are like assetchains but with support for smart contracts. I haven’t found many details about geckochains, and they don’t appear to be available yet, but the Komodo client does currently support assetchains via a command-line interface.

BarterDEX

SuperNET’s decentralized exchange, called BarterDEX, allows users to atomically trade coins across supported blockchains in a trustless way. The team has not yet integrated it into the Agama wallet’s user interface, but they’re working on it now, and in the meantime BarterDEX can be used on its own.

BarterDEX consists of three main components: a designated set of nodes for matching orders; a set of “liquidity provider” nodes to act as market makers; and a protocol for users to exchange coins from two different blockchains with each other as a single, atomic operation.

The order-matching nodes serve the same role as they do in Waves: they partially centralize the task of matching buy and sell orders in order to provide a more responsive user experience. This way, traders don’t have to wait for the next blocks on the blockchains in question to know whether their orders have been filled or to cancel an order.

Liquidity provider (LP) nodes maintain balances of at least two supported coins and automatically trade them at a user-defined profit margin relative to a centralized exchange. For example, it is possible to set up an LP node that trades BTC and KMD on BarterDEX and also on Bittrex. Operators of LP nodes assume the risk associated with holding funds on a centralized exchange, and in return they profit from arbitrage opportunities between the two markets. Other BarterDEX users, for their part, get more liquidity and tighter bid-ask spreads than they would see otherwise, without having to store their coins on centralized exchanges.

After a user’s order is matched, likely to an order submitted by an LP node, BarterDEX uses an atomic cross-chain swap protocol to settle the trade on the two blockchains involved. Presumably the details vary somewhat depending on the trading pair, but conceptually the process is similar in each case. One blockchain is assumed to be compatible with Bitcoin, or at least to support the equivalent of Bitcoin’s hashed timelocked contracts (HTLCs). The other blockchain must support 2-of-2 multisig transactions.

Suppose Bob is trading his funds on the Bitcoin-compatible chain for Alice’s coins on the other chain. Alice and Bob each create a public key/private key pair and exchange public keys and hashes of the private keys. Alice sends Bob a 2-of-2 multisig transaction that he can spend once he knows both private keys, and Bob sends Alice a hashed timelocked transaction that Alice can spend by revealing her private key. Once she does, Bob uses it to unlock her multisig transaction and the trade is complete.

The protocol adds a bit of complexity to protect each party in the case that the other exits the process early. If Alice walks away without spending the transaction that Bob sent, Bob can recover his funds after the timelock on that transaction expires by using his own private key. Conversely, in order to protect Alice from the same risk, the protocol requires Bob to submit an initial “deposit” in the form of a hashed timelocked transaction. If he walks away before paying Alice, she can wait for the timelock on this deposit to expire and claim it for herself.

This is admittedly only a high-level overview of the atomic swap protocol, but hopefully it gives you an idea of how it works. The most important part is that there is no centralized exchange to facilitate the trade: Alice and Bob have exchanged coins on different blockchains without having to trust each other or some intermediary. You can find more details in the BarterDEX white paper.

Compared to Ardor

What do we make of Komodo and SuperNET, then? This question largely hinges on whether Komodo’s delayed proof-of-work algorithm offers a substantial degree of additional security to Komodo and its assetchains. In my view, it does not: it offers roughly the same degree of security as the delegated proof-of-stake algorithm, even if the notary blockchain is assumed to be perfectly immutable.

In this light, Komodo’s assetchains look a lot like the user-deployable sidechains that Lisk and Stratis aim to offer. In all three projects, and in contrast to Ardor’s child chains, each assetchain or sidechain is responsible for its own security. Komodo seems to have a head start on both Lisk and Stratis in terms of functionality, though, as users can already deploy their own assetchains and conduct atomic swaps on some pairs.

Note that Ardor’s child chains store hashes of their blocks on the Ardor chain, rather like Komodo stores hashes of its blocks on Bitcoin, but there is a crucial difference: Ardor’s forging nodes validate all child chain transactions. Each child chain effectively inherits all of the forging power of the Ardor chain, rendering it just as secure as Ardor and obviating the need for separate miners or forgers.

With regard to cross-chain atomic swaps, Ardor and Komodo are perhaps a bit more comparable. Ardor natively supports transactions among child chains and also between each child chain and the parent chain. Moreover, it supports a phased transaction type that is equivalent to 2-of-2 multisig, enabling the same kinds of atomic swaps with Bitcoin-compatible blockchains that BarterDEX uses. Ardor even adds the ability to combine multiple phasing conditions with Boolean AND, OR, and NOT operators, potentially allowing users to create the equivalent of a hashed timelocked transaction. Using BarterDEX’s approach, this feature could enable atomic cross-chain swaps to any blockchain that supports 2-of-2 multisig.

Conclusion

SuperNET’s vision of independent but interconnected blockchains is quite compelling, and between the Komodo platform, the Agama wallet, and the BarterDEX exchange, SuperNET has made real progress towards realizing that vision. While I am skeptical that the delayed proof-of-work algorithm provides substantial additional security to Komodo and its assetchains, the ability to quickly deploy an assetchain at least puts Komodo ahead of Lisk and Stratis in the race to build a functioning sidechain platform. Also, I see a lot of value in the ability to easily conduct cross-chain atomic swaps using BarterDEX.

Even so, I have to wonder whether there exists at the heart of SuperNET a fundamental tension between two of its goals. On the one hand, it aims to integrate the best features of many disparate blockchains, providing users and developers a seamless way to enjoy the unique advantages that each chain offers. On the other hand, it has offered Komodo as a single platform to solve most problems, supporting as it does private transactions, user-provisioned sidechains, and, in the future, smart contracts. Success at either of these goals seems to undermine efforts to achieve the other.

Ardor, for its part, also has a compelling vision, and one that is perhaps a bit more coherent: to support a multitude of businesses and projects on its child chains, making available to each a set of prepackaged features, allowing each to interact with the others, and requiring none to provide for its own security or to store forever the histories of the others. Ardor already offers most of the technology required to realize this vision; what remains is for businesses, developers, and users to put that technology to good use.


Try Ardor on testnet

ARDOR Implements Game-Changing Features In New TESTNET RELEASE

Do you remember, back in the day, the first time you got your mind blown? I remember fondly how that happened to me with Nxt. That blockchain bastard repeatedly blew my mind – sometimes several times a week as it implemented feature upon feature at such a frantic pace. As such, I became a part of the embracing high-level community of Nxters and eventually surmounted the steep learning curve. It was totally worth it but afterward, I became hard to impress.

Released today, a brand new Ardor testnet finally made my brain cells feel a tiny bit explosive again, and it feels great! Not just a tiny bit, actually. The client that lands today is blockchain 2.0 evolution at its finest. Let the popular experts, and all the great blockchain visionaries do their talks. Jelurida just wrote it in code. Again. Let others continue to talk about TPS, ignoring scalability and security, we covered it already. And if you don’t know about Nxt, you should read up.

Ardor 2.0.4e

The Nxt and Ardor core dev team at Jelurida presents to you: New asset control features, multiphased smart transactions, a new API for creating regulated tokens on the decentralized Asset Exchange, and a transaction type that allows asset issuers to increase the number of asset shares in existence. All of this is an addition to all the existing core features and API.

This new Ardor testnet release resets the existing testnet and publishes a new Genesis block that tests the transition of data from Nxt to Ardor, based on a snapshot made of Nxt’s mainnet at block 1558000, shortly after the last JLRDA (IGNIS) exchange offer expired.

The testnet Genesis block timestamp has been set to 00:00 (midnight) UTC time
on Monday, Nov 6th, in order to allow time for users to setup nodes check their balances, and start forging.

From the Nxt blockchain has been transferred the following:

  • Accounts (public keys)
  • Account balances
    • IGNIS balances are based on NXT balances, divided by 2, plus JLRDA asset balances. Each of those has been additionally divided by 2, in order to allocate 50% of the testnet coins to developer accounts for testing purposes. There has been a 10% BITSWIFT asset sharedrop distributed proportionately to all IGNIS shareholders.
  • Account info (name and description)
  • Account properties
  • Account control settings for account control by whitelist with no minimum balance.
  • Account aliases transferred to the IGNIS child chain.
  • Janus, JanusXT, and ComJNSXT assets have been imported.
  • Monetary system currencies have been imported to the IGNIS child chain.
    • Only currency code and name. It will be up to each currency issuer to re-issue the currency with the appropriate properties and re-distribute it to users.

Lior Yaffe kindly asks all of us to check our accounts on Ardor and make sure everything has happened correctly:

If you are only interested in checking your balances head to the Jelurida public node , login using your existing NXT Mainnet account id (no need to login using passphrase) and check your ARDR, IGNIS and BitSwift balances. In addition, check your Janus asset balances, aliases, account properties, currencies, account control and all other entities migrated from the NXT Mainnet according to the changelog.

When you check, be aware that your IGNIS and ARDR holdings have been divided by 2 in this testnet release, so 50% of the tokens can be allocated to dev accounts for testing purposes.

Read all details here.

This was to be expected. Massive work, yes, all as promised and fair for a call to shift from one platform to the N(e)XT, Ardor. Pun intended. There are API changes too, and new API, coders please (you must!) check the change-log.

What made my brain cells begin to feel explosive again then?

New features

Yes, the new features. Nxters run. Run out there and share it with the world!

The change-log for Ardor 2.0.4e presents the following new transaction types – add to them all that the Nxt blockchain’s smart transactions and Ardor’s globally scalable, energy efficient child chain platform design can do, and you will see clearly the size of this gamechanger. This is what the release implements:

Asset control

Allows an asset issuer to control her assets. That’s right. As the issuer you decide who can buy and sell them; a small group of selected people, only KYC verified accounts, perhaps. Or you could send non-transferrable assets to a board of holders and give them voting rights over the asset. How about that. Read it again and let it sink in – with this release you, the issuer, will get complete asset control.

No, it’s not the end of a free market. Ignis is free. It is a new opening that allows all new as well as old running businesses to shift their old backend to Ardor and Ignis and receive all the benefits of the blockchain as a business backend, consumer front-end, and even get it cheaply.

Example:

  • Have an ICO/crowdfunding on Ignis
    Upload contracts and legal documents to the data cloud, time-stamped, hashed, let the KYC compliant accounts of your business partners or angels digitally sign the agreements, this will be documented on the blockchain as well.
  • Issue your asset tokens
  • Decide which rights you want to give to your asset holders, and to your market.
  • Distribute assets, each with the rights attached that you assigned to them. Watch them be traded.

Selected (or all) asset holders can have voting rights. You can pay dividends in any token on the platform; IGNIS, another child chain coin, an € pegged coin, that can be withdrawn with your VISA/Mastercard or just sit in your bank account. Or in other assets, representing bonus points, tickets, whatever fits your business plan. You could even create games with this. It is here.

We welcome this Java code, the Asset Control feature, as one of the best newest addition to the already existing API.

Composite Phasing

Introduces AND, OR, and NOT to Nxt’s Phased Transactions. This, combined with the new Asset Control feature, adds whitelist control over asset holder accounts, you can choose, for example, which asset holders should have the opportunity to vote or even control an account by vote. Even control the whitelist of new accounts. Do you see the better DAO coming?

It also allows for example combining the existing by hash or by transaction approval models with by whitelist, by balance, etc, approvals, which enables doing atomic coupling of transactions (including cross-blockchain) even for multisignature accounts, or with assets subject to Asset Control.

I couldn’t say it better.

The NOT operator allows for dead-man-switch type conditions, where a transaction is executed only if some condition (e.g. revealing a secret) is NOT satisfied.

Source

Asset share increase

With this new smart transaction type, asset issuers can increase the number of assets in existence. Print new money?!!

The new shares are allocated to the asset issuer account, but can then be distributed to shareholders using a separate dividend payment transaction. This allows corporate actions such as capital increases or stock splits to be performed.

Be careful, like we all learned in Economics 101, increasing the supply of money will decrease the value. Take care not to dilute your asset into nothingness.

By-Property phasing

First, if you don’t know Nxt’s feature “Account Properties”, I should fill you in: Account Properties is a Nxt feature that adds the ability to permanently ‘tag’ any account on the blockchain with a small amount of data, like meta-information. Tags can also be deleted by the tagger.

Let’s see what By-Property phasing is:

 

The new by-property approval model allows the transaction execution to be made conditional on the sender account or the recipient account having a specific account property set. If this property is set, the transaction will be executed immediately, else, a second check whether the property is set is performed at the finish height defined. This allows, for example, enforcing KYC by asset issuers, who can define in their Asset Control settings that only KYC-verified accounts, labelled with a predefined account property by a trusted authority (or the asset issuer itself), to perform transactions with their assets.

So with this feature, the blockchain market is regulated.

With this, you can, for example, in the near future, issue an asset on any Ardor child chain, trade it on any child chain, but enforce/be enforced to only let KYC approved accounts trade it on the market. Or choose by country. Or any group. With Ignis, asset issuers and traders can choose whether or not to trade on the regulated market, but we all know: Regulation will be. The new By-Property phasing API makes it not just possible but also easy and cost-effective to develop as a user-friendly service, and yeah, remember, the main purpose for Nxt 2.0, Ardor, was actually to make it globally scalable.

Where does this leave us? Accounts can be tagged by 3rd party KYC service providers or, even better, by governments, may they ever choose to set official ID on accounts and begin using the benefits of the blockchain. Don’t get me started. Secure us, our medical records, money, ID – let us be secured by cryptography. Jelurida’s code does it for them. Give us voting rounds that cannot be interfered with as the result is public, and votes have already been counted by code, see the graph. It’s on blockchain, but energy efficient, secured by nodes all over the world, and while we’re at it – possible. And see, Ardor has, as another first, a solution to the blockchain bloat problem running in production. The first and most tested globally scalable PoS Platform. It’s here, get started.

Sure I am excited. I’m a Nxter. Aren’t you?

Come on, try it!

For newcomers, it may seem weird that scammers and developers collect millions and millions of dollars worth of ETH or BTC in ICO’s, selling their whitepaper only, describing smart contracts they want to invent, code, test, execute, and need us to trust, when old Nxt Cryptocurrency 2.0 already has the functionality that most of them seek. It’s weird that what most of all of these devs and their investors are trying to achieve already exists on Nxt, that now gets further ahead with the scalable and even more beneficent and featureful public Ardor Platform. Yes, it IS weird, that Nxt has been under the radar and ignored by, for example, the larger Bitcoin-paid media for so many years.

The Nxt core devs, Jelurida, has split Nxt into IGNIS, the transactional token of Ignis, the first and unrestricted full featured child chain on Ardor; the mother blockchain that forges all Ignis’ transactions and will give birth to a lot more and take care of all her children (child chains), as well as make sure they keep communicating with each other. This is Ardor. With Nxt being a blockchain 2.0 platform, should Ardor be called blockchain 3.0? Nxt 4.0? Who cares. If you’re just a little familiar with Bitcoin, blockchains and smart transactions, you will realize that you want to test this release.

For those who want to setup an Ardor full node, install the software as usual and start forging, the first block will be generated tonight at 00:00 (midnight) UTC time on Monday, Nov 6th (about 14 hours from now)

If you are installing on top of a previous Ardor release delete first the nxt_test_db folder from C:\Users\<username>\AppData\Roaming\Ardor on Windows, ~/.ardor on Mac and the Ardor installation folder on Linux. If you don’t do that you’ll be left on a fork.

Follow the development closely and take part in the community. Even without the awesome potential that awaits us with this momentous release, it’s always mindblowing development.

 

Ardor vs. the Competition, Pt. 5: Stratis

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

This week I studied Stratis, a blockchain-as-a-service platform based on the Bitcoin protocol.

Stratis

The goal of the Stratis project is to enable businesses to create their own customizable blockchains, choosing from a set of prepackaged features. Additionally, the Stratis Group, which guides the development of Stratis, will offer consulting services to help businesses find ways to use blockchain technology effectively, and presumably will also help them configure and deploy custom blockchains on the Stratis platform.

Put this way, Stratis sounds an awful lot like Ardor. But in most of the details–to the extent that details about Stratis are available, anyway–the two platforms are quite different. More on those differences in a bit.

Currently, the Stratis platform comprises several parts:

  • NBitcoin, a comprehensive Bitcoin implementation in C# inspired by Bitcoin Core;
  • NStratis, a fork of NBitcoin that adds a proof-of-stake mining algorithm and an alternative proof-of-work algorithm;
  • the Stratis Bitcoin Full Node, which can run on either the Bitcoin network or the Stratis network, and which serves as the basis for the rest of the platform;
  • the Breeze Wallet, a simplified payment verification (SPV) wallet for both Bitcoin and Stratis that implements TumbleBit to make transactions private; and,
  • the Stratis Identity module, which allows third parties to attest to the identity of the person controlling a Stratis account.

Note that most of these components are currently in alpha.

Particularly noteworthy in this list is the integration of TumbleBit into the Breeze Wallet. The TumbleBit paper is rather dense; if you’re interested in the details, I recommend instead this excellent presentation by two of the authors. In a nutshell, TumbleBit uses one-way payment channels to transfer funds from a set of payers to an intermediary called the Tumbler, and from the Tumbler to a set of payees, without any of the parties having to trust one another. The key innovation over other payment channel implementations is that TumbleBit uses blind RSA signatures in a clever way to prevent the Tumbler from knowing which incoming transaction maps to a given outgoing transaction. If many accounts are transacting through the Tumbler, then it is impossible to trace the funds in an output account back to the input account that sent them. Not even the Tumbler can link the two accounts.

Stratis’s Breeze Wallet provides TumbleBit functionality for both Bitcoin and Stratis, making it useful to a much larger audience than would be the case if it worked only on the Stratis network. Moreover, since the TumbleBit protocol uses off-blockchain payment channels, it is possible to make many payments through the Tumbler in approximately the same amount of time as it takes to make a single payment.

The Stratis Identity module is still at the proof-of-concept stage, but it is functional nevertheless. Users can log into their Microsoft, Google, or LinkedIn accounts using the Stratis Identity mobile app, and these services will notify Stratis of the successful login. A special account owned by Stratis then records an attestation to the successful login by hashing the corresponding personally identifiable information (e.g., name and email address) and storing it on the Stratis blockchain.

An attestation by Google that a person owns a particular Gmail account is perhaps not the most useful identity service, but it is easy to see how the same mechanism could be used to prove ownership of some piece of information that is much more difficult to verify. For example, a government agent might attest that somebody presented a valid photo ID, together with a name and address. If a user can provide the name and address that match the hash on the blockchain, that would probably convince a service provider that the user also owned the corroborating photo ID, since the government agent attested to all three pieces of information together.

TumbleBit integration in the Breeze Wallet and the Stratis Identity module are two examples of the kinds of features that Stratis intends to offer on their platform. I’m not completely sure I’ve grasped the overall architecture of Stratis, but from what I can understand, the idea is for the Stratis blockchain to delegate the backend processing for each new feature, such as TumbleBit and Stratis Identity, to a dedicated set of masternodes. For example, the upcoming Breeze Node–not to be confused with the Breeze Wallet, which uses SPV instead of requiring a full node–will be a masternode that serves as a Tumbler. Similarly, there are plans to build masternodes that process Stratis Identity transactions, though I don’t really know what that means and can’t find any details.

Finally, it is worth mentioning that the Stratis team has planned several other features, most notably a way to deploy sidechains anchored to the Stratis chain. My understanding is that this will be the main mechanism that Stratis uses to provide customizable, private blockchains to clients.

Unfortunately, I haven’t been able to find any details about how sidechains on Stratis will work. The Stratis white paper refers to Blockstream’s sidechain paper, but that is the only hint I have found so far about Stratis’s design. In particular, it is not so easy to securely and trustlessly transfer value between two blockchains without having at least some of the miners on each chain validate all transactions on both chains. The details, including how the sidechain protocol handles forks and reorginzations, are crucial in order to evaluate how secure the mechanism is.

Even supposing that transfers between the Stratis chain and sidechains are secure, there is also the matter of the security of the sidechains themselves. The Stratis white paper says in several places that the Stratis chain will somehow provide security for its sidechains, but it doesn’t explain how that will work. Typically, sidechains are completely independent and must secure themselves.

Compared to Ardor

With Ardor, on the other hand, the parent chain does provide security for each child chain.

In fact, this is one of the most important differences between Ardor’s parent-chain/child-chain architecture and typical sidechain implementations. Unfortunately, without more technical details from the Stratis team, it is impossible to do a proper comparison between their design and Ardor’s approach.

One comparison that we can do is between Stratis’s TumbleBit feature and Ardor’s Coin Shuffling feature. (Note that Coin Shuffling will not be available on the Ardor chain itself, but it will be available on Ignis, the first child chain, and other child chains can also choose to support it.) This feature is Nxt’s implementation of the CoinShuffle algorithm, which allows a group of users to trustlessly agree to transfer a fixed quantity of coins from their (input) accounts to a set of output accounts, one per input, without any user being able to know which of the other users controls each of the other output accounts. The algorithm is not very complicated, and section 4.2 of the CoinShuffle paper gives a good overview of how it works.

I don’t claim to be an expert on either algorithm, but the TumbleBit approach seems to me to have a couple of advantages over CoinShuffle. Because it uses off-blockchain payment channels, it is potentially capable of scaling to a high transaction rate in addition to adding a measure of privacy to payments, addressing two problems at once. Also, if the goal is to prevent an observer from noticing correlations between several payments–which might leak information about a business’s customers or supply chain, for example–it would probably be more convenient to make the payments back-to-back from the same account via TumbleBit instead of having to first shuffle each payment to a new account.

On the subject of identity verification, I think the Stratis Identity module is an interesting proof of concept, but in my opinion Ardor provides a much richer set of tools for identity-related services. While a service like Stratis Identity can be built relatively easily on any blockchain, Ardor offers a couple of unique features that could extend such a service for some interesting applications.

On Ardor, identity validators will be able to attest to the identities of account owners using Account Properties. These are arbitrary bits of data that can be permanently associated with an account on the blockchain, rather like attestations in Stratis Identity. One novel feature that Ardor will add, though, is the ability to issue assets that can only be traded by accounts that have a specific property set.

In cases where government regulations require that asset issuers know who is purchasing their assets, this feature will allow issuers to restrict trading of their assets to accounts whose owners’ identities have been verified by compliant identity providers. This level of control will hopefully help put blockchain-based securities on a firmer legal foundation, and will make it easier for asset issuers to comply with the law.

Even apart from regulatory compliance, asset issuers will probably find other uses for this feature. For example, a club or other private organization could express eligibility requirements for membership as a set of required account properties, issue an asset that only eligible accounts could obtain, and then use the asset to pay dividends to or conduct polls of members.

Some Thoughts on Marketing

Even having read this far, you might still be wondering what exactly the Stratis platform is and how it works. To be frank, I have found myself asking these questions too, even after many hours of reading about Stratis. At the risk of speaking perhaps a bit too close to the edge of my knowledge, I think it might be helpful to compare and contrast the marketing efforts of Jelurida and the Stratis Group in order to shed some light on why it is hard for me to answer these very basic questions.

Reading the Stratis website and the white paper (linked above), I got the distinct impression that, to be blunt, those resources weren’t really written for me. The language they use reminds me of how the salespeople at my company talk, and I learned a while ago that engineers and salespeople tend not to understand each other very well.

I read that Stratis offers “simple and affordable end-to-end solutions” to “streamline and accelerate [my] blockchain project development”; that it is a “powerful and flexible blockchain development platform designed for the needs of real-world financial services businesses and other organizations that want to develop, test and deploy applications on the blockchain”; and that its “one-click process means that new chains can be launched with unprecedented speed, tailored for the needs of the organization”; but I still don’t really understand what any of this means, much less how Stratis will accomplish these things.

This type of language conveys precisely zero information to me. Without technical details, I am completely, hopelessly lost. I know that there are plenty of people who are fluent in business-speak, though, and those people can probably read the Stratis white paper and come away with a decent, if very high-level, understanding of what the company plans to do. In contrast, it took me multiple passes through the white paper before I began to grasp the big picture, and I’m still not sure I have it right.

The Ardor white paper, on the other hand, contains substantial technical detail about how Ardor works and what distinguishes it from other blockchain platforms. It is obvious, both from its content and how that content is organized, that engineers played a significant role in writing it. Upon completing my first pass through it, I understood pretty well what problems Ardor solves and how it solves them.

The point I’m trying to make with this comparison is that business-minded people and technically-minded people often speak different languages, and the marketing materials that the Stratis Group and Jelurida have created seem to reflect this difference. Personally, I found it extremely frustrating to find so little technical substance in Stratis’s resources, and this frustration has probably prevented me from really understanding Stratis.

Conclusion

Is my assessment of Stratis too harsh? Maybe. I do think that TumbleBit is an interesting piece of technology, and it seems smart for the Breeze Wallet to implement it for both Stratis and Bitcoin. Moreover, if we drop the white paper’s contention that the Stratis chain will secure its sidechains, and instead assume that sidechains will be responsible for their own security, then I can use my imagination to fill in enough of the gaps to come up with at least a rough mental image of what Stratis will look like when it is complete.

This mental image, though, is basically a direct competitor to Lisk. Sure, Stratis is based on .NET and the Bitcoin protocol instead of JavaScript and Lisk’s predefined transaction types, and the feature sets that the two teams intend to offer don’t overlap perfectly, but essentially both projects aim to provide a central, public blockchain and a set of tools for easily creating sidechains on it. Both projects are in rather early stages of development, too, and for this reason it can be difficult to find technical details about them.

Ardor is quite different. Built on the Nxt codebase, it is already far more mature than Stratis, despite not having launched on its mainnet yet. Its parent-chain/child-chain architecture achieves the goal described in the Stratis white paper–a means for businesses to create customizable blockchains without having to worry about securing them–better than existing sidechain architectures. And the rich variety of features that Ardor already supports will take quite some time for Stratis to emulate.

Perhaps just as importantly, Jelurida and the Nxt community have done a great job of making technical information about Ardor and Nxt publicly available. This information lends credibility to the Ardor project and strengthens the community. In my opinion, it is what separates true marketing from hype.


Try Ardor on testnet

Ardor vs. the Competition, Pt. 4: Waves

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

Until now, one of my main goals with this series has been to survey different approaches to scaling a distributed ledger. This week and for the next couple of posts, though, I’m shifting my focus slightly towards the business side of blockchain technology. I’ll attempt to explore the real-world problems that blockchains can solve and the ways that different projects have positioned themselves to suit their target markets.

These subjects are a bit outside my comfort zone, so I’ll thank you in advance for your patience with me in case I say something ignorant or naive. And as always, I greatly appreciate constructive criticism. 🙂

This disclaimer is especially important this week, because this week I studied Waves. As a newcomer to Nxt, I’ve read just enough about its history to know that the founder of Waves, Sasha Ivanov (a.k.a. Coinomat on nxtforum.org), had been an active member of the Nxt community until the turbulent period of early 2016, at which time he left to found Waves. I won’t attempt to rehash the debate over Ardor and the future of Nxt, which I understand ended with many asset issuers like Sasha leaving the community, but if you’re interested I’d highly recommend apenzl’s summary in SNAPSHOT and the references therein.

Instead, for this post I’ll mostly ignore the histories of Nxt and Waves, and will approach both projects with an open mind and a view towards the future. I do think there would probably be some value in a proper historical analysis, but I simply am not qualified to offer one.

With that out of the way, let’s talk about Waves.

Waves

At first glance, Waves looks a lot like a stripped-down version of Nxt. It is primarily a decentralized exchange (DEX), inspired by and conceptually similar to the Nxt Asset Exchange. Like Nxt, it uses a proof-of-stake consensus algorithm and allows users to lease their balances to other accounts in order to forge in pools. It recently added a way to associate a human-readable alias to an account number, partially replicating the functionality of Nxt’s Alias System. Even a couple features still in development–namely, a voting system and a way to send encrypted messages–duplicate functionality that Nxt already offers.

At the same time, Waves is missing many of Nxt’s most powerful features. For now, it doesn’t support anything similar to Nxt’s phased transactions or account control options, for example, though it is worth noting that both smart contracts and multisig transactions are on the agenda.

Additionally, the white paper suggests that crowdfunding will be one of the main uses of the Waves platform, but tokens on Waves lack the customizable properties that make Nxt’s Monetary System currencies so useful for this application. For example, the Monetary System offers the ability to condition the transfer of funds on meeting a fundraising goal, a la Kickstarter, and also the option to restrict trading so as to prevent scalpers from creating a secondary market. Using this latter feature, called a “Controllable” currency in Nxt’s terminology, it is even possible for issuers to dictate both a fixed asking price and a fixed bid for the currency, enabling them to offer buyers full or partial refunds for their tokens. Crowdfunding on Waves, in contrast, is limited to issuing a token essentially at the market rate.

These observations notwithstanding, in my opinion it would be a terrible mistake to dismiss Waves as just another Nxt copycat with fewer features. For one thing, Waves offers several key features that Nxt and other platforms do not have, which I’ll describe next. Perhaps even more importantly, though, the Waves team has built a strong brand and has offered a clear and consistent vision since the platform’s inception. The field is currently so crowded, and innovation so rapid, that the combination of a simple, clear message, a strong marketing effort, and a demonstrated ability to deliver on those promises might be even more important to the long-term success of a project than the richness or novelty of its underlying technology.

Unique Features

One interesting feature that distinguishes Waves from many other platforms is the design of its DEX. It is a hybrid approach that combines a centralized order-matching engine, called the Matcher, with decentralized settlement on the Waves blockchain.

When users place orders on Waves, the Waves client sends those orders to central Matcher nodes, which maintain the order books for all tradeable pairs. Each new order is either matched against existing orders or added to the order book for the pair in question, but either way the user who submitted the new order is notified immediately whether the order was filled. It is still necessary to wait for the next block(s) to be added to the blockchain to fully confirm the transaction, but in the meantime, the user knows with high confidence the result of the order.

This might not seem like a big improvement over a fully decentralized exchange, but from the handful of transactions I made on Waves, I must say I was quite impressed by the user experience. The ability to see real-time updates to the order book, and to know immediately whether my orders were filled, made a bigger difference than I had expected.

In principle, any full node can become a Matcher. The lite client currently only connects to Matchers at nodes.wavesnodes.com by default, though, so Matchers on the rest of the network probably do not see much volume. With new orders transmitted directly to these centralized nodes, and only broadcast to the whole network once they have been filled (I think), this design allows the order books to remain anonymous. I don’t know for sure how important it is for open orders to be anonymous, but it certainly seems like a feature that traders might value highly.

Another distinguishing feature of Waves is the ability to trade any token against any other token without first converting to WAVES. Combined with the integrated gateways that issue tokens pegged to U.S. dollars, euros, and several cryptocurrencies, this feature enables Waves to function as a decentralized foreign exchange market. It also allows token issuers to conduct an initial offering directly in fiat-pegged tokens. With the full client, it is even possible to pay fees in tokens instead of WAVES.

Additionally, it is worth noting that there are several features in development or on the roadmap that also distinguish Waves from other platforms. One is a reputation system that will score accounts by their age, transaction history, and other factors. There are not many details yet, but the goal is to provide users with at least a rough indication of how trustworthy a given token issuer is. The white paper even goes so far as to suggest that the reputation system will serve as “some form of decentralized KYC/AML” (know your customer/anti-money laundering) system. While it’s difficult to see how a decentralized reputation system could help issuers actually comply with KYC and AML laws, it’s not unreasonable to suppose that it could serve some analogous purpose in a blockchain community.

Speaking of compliance issues, Waves has also announced a new project, Tokenomica, that will provide a “100% compliant legal framework for different types of token crowdsales, including private equity crowdsales.” Unfortunately, that quote from the 2017 roadmap is just about the full extent of information I’ve been able to find about Tokenomica. My impression is that the project is still in its early stages, but it shows that the team is taking regulatory compliance seriously.

For completeness, I should probably mention that the Waves team is also planning to incorporate smart contracts into Waves. The scripting language will not be Turing complete, and there will be no equivalent to Ethereum’s concept of “gas,” presumably because there will be no loops. Beyond these details, there isn’t much other information available yet.

Finally, I must mention the approach that the Waves team has outlined for scaling. It consists primarily of two parts: a redesign of the forging process that breaks large blocks into “microblocks” to optimize bandwidth usage; and an optimization to how account balances are stored–or rather, not stored–that reduces memory requirements for full nodes.

The first of these two proposals, called Waves NG, is based on Bitcoin NG. In a nutshell, once a node has won the right to forge the next block, it immediately issues a key block, which is usually empty, and then broadcasts microblocks containing transactions every few seconds. The motivation for this design is that broadcasting one large block each block interval is a much less efficient way to use the network’s bandwidth, and the corresponding spikes in network activity place an artificially low bound on the number of transactions that the network can handle. By spreading transactions out over a sequence of microblocks, it is possible to increase the average data rate over the network but decrease the peak data rate, lessening the constraints that bandwidth and latency impose on the maximum transaction rate.

The second component of the scaling plan is to implement the ideas described in this paper by Leonid Reyzin, Dmitry Meshkov, Alexander Chepurnoy, and Sasha Ivanov. I admit I haven’t spent very much time with it, but the gist is that full nodes will not all be required to store every account’s balance of every token in memory in order to validate transactions. Instead, they will store a compact digest of this information, and forgers that do store it in full–or some subset of it, if they choose to only forge transactions involving specific tokens–will generate cryptographic proofs that they have updated the account balances correctly. The forgers will then include the proofs and an updated digest in the header of each new block. Nodes that have chosen not to record the balances of all tokens involved in those transactions will still be able to validate them by using their current digest and the forger’s proofs to compute an updated digest, which they can compare to the one the forger reported.

The authors argue that this approach can reduce the amount of memory required for a full node under realistic conditions by about a factor of four. Moreover, if this optimization is able to keep all required information in memory in cases where it would otherwise have to be stored on disk, the performance improvement could be far greater–about a factor of 20, the authors suggest.

Comparison with Ardor

Although a couple of the features described were not present in Nxt, there will be similar features available in Ardor.

Specifically, Ardor’s parent-chain/child-chain architecture will allow users to trade all pairs of child chain coins, some of which could be pegged to fiat currencies and other cryptocurrencies. It will also be possible to price assets in any of the child chain coins, and to pay fees in the child chain coin when transacting on a given child chain. It will not be possible to trade assets against each other directly, but most of those trading pairs would probably have such low volume that it wouldn’t really be worthwhile to add this feature anyway.

As for the improvements that the Waves team has made to their DEX by partially centralizing it, it should be possible to mimic this functionality pretty closely by building a centralized order matcher on top of Nxt/Ardor. Indeed, the InstantDEX project accomplished something similar in the past, using Nxt to settle transactions in a decentralized manner.

On the subject of scaling, the proposal to reduce in-memory storage requirements for full nodes is intriguing, but I wonder whether there might be a small trade-off with security. (If you’ve read the previous articles in this series, then you have probably figured out by now that I always suspect that performance improvements entail reductions in security.) In particular, if nodes are not required to store the current state of every account, and must use the proofs and digest in each new block’s header to validate the transactions contained in it, then I assume that means that nodes will not be required, nor even will they be able, to validate unconfirmed transactions before broadcasting them to their peers. I don’t know the consequences of allowing nodes to propagate potentially invalid transactions across the network, but the thought makes me a bit uneasy.

Ardor’s approach to scaling is for all nodes to validate all transactions, but for only the minimum possible amount of information to be permanently recorded on the Ardor blockchain. In particular, only those transactions that change the balances of ARDR, the forging token, need to be stored on the blockchain in order for other nodes to trustlessly verify that each block was forged by an account that was eligible to do so. In contrast, the whole history of transactions involving only child chain coins and the assets and currencies traded on those child chains does not need to be stored on the blockchain, and hence can be pruned away, leaving only cryptographic hashes of that information behind. The result is that the blockchain stays much smaller and grows more slowly than would be the case if it stored all of this extra information.

Which approach is better depends on whether permanent storage of the blockchain or in-memory storage of current account balances presents a bigger problem as the two platforms grow. I don’t know the answer to this question, but there are a couple of related points that are probably worth making. One is that the timescales of the two problems could be quite different: I could see an explosion of new assets on the Ardor platform placing an immediate strain on memory, whereas blockchain bloat would likely pose a severe long-term problem for Waves, especially if it reaches hundreds or thousands of transactions per second, which is the current goal. My other thought is that Ardor required an entirely new architecture to implement its scaling solution, whereas Waves’s approach will not. It would no doubt be easier for Ardor to incorporate Waves’s solution at some point in the future than for Waves to implement Ardor’s solution.

Finally, perhaps the most interesting subject in this comparison is the issue of regulatory compliance. Waves has positioned itself as a platform for creating and issuing tokens, with a special focus on crowdfunding. To that end, the Waves team has indicated that they are taking a serious look at the regulatory complications that go along with crowdfunding–which might involve selling securities, for example–in order to help users comply with the law. While the suggestion that a decentralized reputation system might eventually replace traditional KYC/AML requirements strains credulity, it could at least help suppress scams and reduce the opportunities for bad actors to take advantage of others. In that sense, it might accomplish some of the same goals that regulators aim to achieve.

Ardor, for its part, will offer a couple of enhancements over Nxt that will be quite valuable for regulatory compliance. One is the ability to issue assets that can only be traded with a certain type of phased transaction, and the other is the addition of a new phased transaction type, which allows an account to approve a transaction only if the account has a certain specific property. Combining these two features, a user can issue an asset which can only be purchased by accounts that have a property that, for example, a KYC/AML-compliant identity provider has added to designate that it has verified the owner’s identity.

If your asset represents shares of a company, or a mutual fund, or some other type of security, this feature would enable you to prove to regulators that you know who is purchasing your tokens. Moreover, if you are a user interested in purchasing those types of tokens, recording a proof of your identity on the blockchain via your account’s properties will hopefully allow you to spend less time trying to convince businesses that you are who you say you are and that you aren’t laundering money.

In addition, it will be possible to create child chains that support only a subset of the features that the Ardor platform offers. This will allow child chain creators to disable certain features, such as coin shuffling, that might raise red flags with regulators in some jurisdictions.

Conclusion

What, then, do we make of Waves? There is definitely something to be said for choosing one problem and trying to solve it better than anybody else can do. Abandoning Nxt’s “Swiss Army knife” approach and focusing instead on the single goal of building a great token-trading platform no doubt made it easier to pitch, develop, and market Waves. There is also a lot to be said for starting off well-funded, as Waves did with a $16M ICO.

At the same time, though, I’m not sure that an objective comparison of Waves and Ardor could conclude that Waves is as technologically mature as Ardor is. (For the record, I have tried to do a fair and objective comparison in this article, but I am not claiming that I succeeded. That’s ultimately your call.) Nxt is already capable of almost all of what Waves can do, not to mention all of the things that Waves cannot do, and Ardor is adding new functionality, too.

Perhaps Ardor’s biggest remaining challenge is to truly sell its vision the way that the Bitcoin community and the Ethereum Foundation have sold their visions, and this is where Waves has a sizable head start. Being capable of so many different things, but not purpose-built for anything in particular, Ardor faces a very difficult task here. The worst possible outcome would be for users and businesses to see it as “just another platform,” or perhaps to fail to grasp the full range of what it can do, and to simply ignore it as a result.

As for Waves, I’m excited to see what the future holds. The improvements that it has made to the Nxt Asset Exchange, though modest in my opinion, have nonetheless distinguished it as a formidable DEX. If the Waves team can follow through on their roadmap, Waves will be a fierce competitor among exchanges–centralized and decentralized alike.

Ardor vs. the Competition, Pt. 3: IOTA

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

This week I studied IOTA, a distributed ledger that doesn’t use a blockchain.

Why Compare Ardor and IOTA?

At first blush, IOTA is about as different from Ardor as a distributed ledger can be. It uses a directed acyclic graph (DAG), which its developers call “the tangle,” to represent the history of transactions, instead of storing transactions on a blockchain. It is intended to be used primarily for machine-to-machine microtransactions on the Internet of Things (IoT), a vision enabled by the fact that IOTA requires no transaction fees. And it doesn’t (yet) support the “blockchain 2.0” features that form a core part of Ardor’s appeal. On the surface, it doesn’t really look like a competitor to Ardor.

So why include IOTA in a series entitled “Ardor vs. the Competition”?

As I’ve mentioned before, my main interest with this series is in exploring different distributed ledgers’ approaches to scaling, and this is where the IOTA community has made some extraordinary claims. As I learned more about IOTA to better understand how it scales, I eventually came to the conclusion that IOTA and Ardor offer complementary (or more bluntly, opposite) solutions to the scaling problem:

Ardor dramatically reduces blockchain bloat but requires all nodes of the network to agree about the strict ordering of transactions; whereas IOTA achieves potentially higher throughput by relaxing the consensus rules a bit, allowing temporary discrepancies between transactions, but faces a significant challenge in coping with the growth of the tangle. These tradeoffs, plus what I learned about the security of the tangle, seemed interesting enough to warrant a post in this series.

If you aren’t convinced, though, please still check in next week!

After this post, I plan to shift my focus away from scalability and towards features and market fit. Stratis, Ark, and Waves are on the agenda, but I’m not sure of the order, yet.

The Tangle

Without a doubt, the key distinguishing feature of IOTA is the tangle.

IOTA’s other unique features, such as its lack of transaction fees, the fact that transactions are not strictly ordered but still eventually consistent, and the notion that (some) spam actually increases the throughput of the network, all stem directly from the way the tangle works.

For this reason, and also because I want to sidestep at least some of the recent controversy surrounding the IOTA project, I will try to focus primarily on understanding and evaluating the tangle itself, rather than picking apart the details of IOTA’s specific implemetation of it.

The tangle is a directed acyclic graph whose vertices represent individual transactions, and whose edges represent “approvals” of previous transactions. Each time a node submits a new transaction to the network it must choose two previous transactions to validate, which it references in the new transaction it submits. As the new transaction permeates the network, each node adds it to its local copy of the tangle, with one edge pointed to each transaction that the new transaction approved.

I tried my best, but this description is probably confusing. This diagram should help. Each square represents a transaction, and the arrows that point from each transaction to two others represent that transaction’s approval of the two earlier ones. The genesis transaction is somewhere far off the left side of the diagram, and the newest transactions, called “tips” in the white paper, are on the right side, shaded in gray.

What does it mean to validate, and hence approve, a transaction? Conceptually, the node doing the validation must start at the two transactions that it is validating and walk all paths back to the genesis transaction, ensuring that it never encounters a contradiction (e.g., double-spend, insufficient balance, or the like). If there is a contradiction, it chooses another pair of transactions to approve, knowing that no other node would ever approve the transaction it is submitting if it had approved a set of inconsistent transactions.

Notice that this means that each new transaction not only directly approves each of the two transactions it has chosen to validate, but also indirectly approves the transactions that those two approve, and the transactions that those transactions approve, and so on all the way back to the genesis. This is part of the basis for “eventual consensus” on the tangle.

In case you’re wondering about the computational burden of doing this validation, in practice it can be optimized substantially. Notice from the figures on this page that as you walk the tangle from the tips (far right) towards the genesis, you eventually reach a point past which all transactions are (indirectly) approved by all tips. In these figures, transactions approved by all tips are colored green. You could, therefore, cut the tangle across arrows that point to green transactions, validate the paths from those particular green transactions to the genesis a single time, cache the results, and from that point forward only validate from your new transaction back to those green transactions. This optimization saves you the time of validating the entire tangle every time you submit a transaction, and also allows the tangle to be pruned. More on that below.

Consensus

One very interesting feature of a tangle-based ledger like IOTA is that nodes that receive new transactions from their peers don’t have to immediately validate them. In fact, the tangle can temporarily contain contradictory transactions. Eventually, though, a node must decide which of the contradictory transactions to approve (possibly indirectly) as it adds a new transaction.

How does it choose between conflicting transactions? Assuming that each transaction is valid if considered separately, then the short answer is that a node could choose to approve either one. It has an incentive to approve the one that the rest of the network will build on, though, so that its own transaction will eventually be approved, too. Most of the nodes on the network are assumed to run the reference algorithm for selecting transactions to approve, so in the event of a conflict, a node has an incentive to choose the transaction that the reference algorithm selects.

In order to understand the reference algorithm, it is important to first understand the concept of the cumulative weight of a transaction.

Each node that submits a new transaction must do some proof-of-work (PoW), which determines the “own weight” of the transaction. The cumulative weight of a transaction is then its own weight plus the own weights of all transactions that have directly or indirectly approved it. In a general tangle the node can decide how much work to do for a transaction, but in IOTA all transactions require the same PoW and thus have the same own weight. As a result, the cumulative weight of a transaction is proportional to the number of other transactions that directly or indirectly approve it.

What, then, is the reference algorithm? The author of the white paper calls it Markov-Chain Monte Carlo (MCMC, see section 4.1), which is a fancy way of saying that it is a random walk along the tangle that favors paths with greater cumulative weight. This post is already getting long, so I’ll skip the details. Suffice it to say that, when there are conflicting transactions, the MCMC algorithm resolves the conflict by tending to choose whichever transaction has the greater cumulative weight behind it. Eventually, one subtangle becomes dominant and the other is orphaned. This is analogous to the mechanism that blockchains use to resolve forks, and the cumulative weight of a transaction in IOTA is a rough measure of its finality in the same way that adding blocks to a blockchain confirms previous transactions with greater and greater certainty.

By the way, the fact that nodes don’t immediately need to validate each new transaction received from their peers has big implications for performance. Each node does less work this way, validating transactions only when it submits a new transaction, and taking for granted that transactions that are indirectly approved by all tips have already been validated by the rest of the network. Also, validations run in parallel across the network, as different nodes choose different subsets of transactions to approve.

Security

So far I have mostly just regurgitated the information found in the IOTA white paper. The issue of the security of the tangle, on the other hand, is where things get a lot more interesting. While I definitely recommend reading the analysis in the white paper of different attacks on the tangle–and the rest of the white paper, for that matter, because it is very well written–I won’t discuss most of that analysis here.

Instead, I want to focus on the most obvious threat, which is a 51% attack. The IOTA devs actually refer to it as a 34% attack, for reasons that I’m not sure I understand. I suspect it’s because an attacker who waits for a fork to occur naturally only needs enough hashpower to out-compute the nodes on each branch of the fork–i.e., more than 50% of the rest of the network’s hashpower. Anyway, the exact number isn’t important, and for the remainder of this article I will use the term “34% attack.”

With IOTA, a 34% attack would look roughly like this. An attacker issues a transaction that spends some funds, represented by the rightmost red dot, then computes (or perhaps has precomputed) his own “parasitic” subtangle, which anchors to the main tangle somewhere upstream of his transaction and which contains a double-spend transaction, represented by the leftmost red dot. His goal is to add enough cumulative weight to his parasitic tangle to convince the MCMC algorithm to orphan the main tangle and follow the parasitic one.

Hopefully, the analogies to the blockchain are clear so far, because there is one more important one. Like a PoW blockchain, the tangle is secured by the current hashpower of the network, since this hashpower is what adds cumulative weight to the legitimate tangle. Unlike a PoW blockchain, though, nodes on IOTA only do PoW when they submit transactions. The security of the tangle, therefore, depends only on the transaction rate and the amount of PoW per transaction. Take a second to let that idea sink in because it is absolutely central to understanding the security of the tangle.

Because the IOTA network is currently small and the transaction rate is low, the IOTA team has established a single trusted node, called the Coordinator, that is ultimately responsible for deciding the current state of the tangle. Its purpose is to protect against 34% attacks, among other attacks. I’m not going to spend any more time on it, but I encourage you to read this critique and the devs’ responses, and draw your own conclusions about whether IOTA can be called decentralized while running under the supervision of the Coordinator.

Let’s see if we can come up with an order-of-magnitude estimate of how secure the network could be without the Coordinator. A recent stress test achieved well over 100 transactions per second (tps) on a small test network. The team suggested that 1,000 tps is achievable. To be generous, let’s assume that IOTA will eventually scale to 10,000 tps. I don’t know what the current PoW requirement on IOTA is, but let’s suppose that the average IoT device is approximately a Raspberry Pi and it runs at 100% CPU for 10 seconds to do the required PoW. Again, I’m trying to be generous; many IoT devices are considerably less powerful than a Raspberry Pi, and pegging the CPU for 10 seconds for each transaction would probably be a dealbreaker.

With these assumptions, we conclude that the average computational power securing the network is roughly 10,000 x (# of computations by Raspberry Pi in 10 s) per second, or equivalently, 100,000 times the computational power of a single Raspberry Pi. There are a lot of nuances to properly benchmarking computers, but we’re not concerned about factors of two or three–we’re just going for an order-of-magnitude estimate–so we’ll use some numbers I found on the internet.

A Raspberry Pi3 can achieve hundreds of MFLOPS (megaflops, or millions of floating-point operations per second), while high-end GPUs clock in at thousands of GFLOPS (gigaflops, or billions of FLOPS), a factor of 10,000 greater computing power. So in our hypothetical scenario, an attacker with ~10 GPUs could out-compute the entire network. Throw in another factor of 10 because I was being sloppy–maybe integer operations are a bit slower on the GPUs than floating-point operations, for example–and you still only need 100 GPUs to execute the attack.

I’m sure there are plenty of holes to poke in this analysis. Perhaps IOTA won’t run on devices all the way at the edge of the network, for example. Instead, it might run on the gateways and routers that those IoT devices connect to, which are typically much more powerful.

Still, the point I’m trying to make is that PoW successfully secures blockchains like Bitcoin and Ethereum because it isn’t tied to the transaction rate, or any other factor besides the economic value of the network. As the value of the mining reward (in fiat currency) increases with the price of Bitcoin, miners add more hardware and consume more electricity to mine it. The economic incentive to mine ensures that the amount of hashpower securing the network increases with the network’s monetary value.

With IOTA, in contrast, there is no economic incentive to secure the network. Moreover, the hashpower securing the network is tied directly to the transaction rate, which naturally has some upper limit dependent on bandwidth and network topology.

On this last point, the IOTA developers have made a creative argument, not included in the white paper, that bandwidth limitations and network topology actually improve the security of the network. I haven’t found an official statement of it anywhere, but after some digging I stumbled upon this Slack conversation, which is the most complete defense I could find.

Essentially, one of the IOTA developers (specifically Come-from-Beyond, a.k.a. Sergey Ivancheglo, possibly a.k.a. BCNext, also one of the original creators of Nxt), argues that the IOTA network will consist of IoT devices peered exclusively with their nearest neighbors in a meshnet topology, and that an attacker will not even have the option of peering with more than a very small number of devices on each such mesh. That is, the vast majority of devices will not be accessible from the internet or some other “backbone” of the network, and the only way to send messages to them will be through the mesh of other devices.

The general idea is that the mesh as a whole will be capable of achieving a high throughput, but each individual link in the mesh has a low enough bandwidth that an attacker would easily saturate it by trying to add enough transactions to convince the network to follow his parasitic subtangle. Since the attacker only has a few entry points into the mesh, he saturates all of them before his parasitic tangle accumulates enough weight for his attack to succeed.

I’ll let you draw your own conclusions about this argument. I personally don’t think the IOTA team has made enough details public to thoroughly evaluate it.

Speaking of bandwidth limitations, let’s talk about scaling.

Scalability

Because each node must validate two other transactions before submitting its own transaction, the IOTA team likes to point out that spam actually tends to make the network more efficient. Other members of the IOTA community get carried away with this point, sometimes even making the absurd claim that IOTA is “infinitely scalable.”

Every node on the IOTA network must eventually receive every transaction in order to maintain a globally consistent tangle. Broadcasting transactions to remote nodes takes time, though, and if the transaction rate is high enough that a node receives a lot of transactions from nearby nodes before it receives the next transactions from distant nodes, the MCMC algorithm will continue to select tips submitted by nearby nodes. Eventually the tangle splits, with only nearby nodes transacting on the local copy of the tangle and remote nodes transacting on their own, divergent copy.

So bandwidth and network topology must place some limitations on the transaction rate of IOTA if the tangle is to be consistent across the entire network. We will have to wait for more stress tests to learn what these limitations are.

Additionally, like all distributed ledgers, IOTA must grapple with bloat. Each transaction on IOTA is approximately 1.6 kB in size, so a transaction rate of 100 tps would grow the tangle at a rate of 160 kB per second, or about 14 GB per day. Needless to say, that’s an unrealistic storage requirement for an IoT device.

IOTA currently solves this problem by taking periodic snapshots of the tangle, which map its current state into a new genesis transaction, allowing the transaction history to be pruned away. In the limit of very frequent pruning, a node would only have to store enough of the tangle to be able to run the MCMC algorithm.

Syncing a new node with the network is a different story, though. Either the node must download the latest snapshot from a trusted peer, or it must start at the original genesis transaction and work its way forward through the entire tangle. There is no way to trustlessly and efficiently join the network.

Finally, it’s worth noting that the IOTA team has proposed a type of horizontal partitioning of the tangle that they call a “swarm,” where many nodes together store the complete tangle but no one node stores all of it. Unfortunately, there aren’t many details yet on how this works.

Compared to Ardor

So what does any of this have to do with Ardor?

In my opinion, there are two main comparisons to draw, namely on the issues of security and scalability.

Regarding security, it isn’t clear to me that IOTA could possibly reach a high enough transaction rate to be considered secure without the Coordinator, given the monetary value of even the current network, without choosing a very high PoW requirement.

Ardor, in contrast, has the advantage that its child chains are all secured by the single parent chain.

A “small” child chain wouldn’t need a trusted node like IOTA’s Coordinator to protect it because consensus is established by the entire network and recorded (via hashes of child chain blocks) by forgers on the parent chain.

On scalability, IOTA and Ardor both currently share the requirement that each node of the network process all transactions. With IOTA, this simply means adding transactions to the tangle, which is computationally cheap, whereas, with Ardor, every node must validate every transaction. Moreover, the clever design of the tangle ensures that the confirmation time for a transaction actually decreases as the network gets busier. I would not be surprised to see IOTA achieve higher throughput than Ardor as both networks grow.

On the other hand, IOTA faces a tremendous challenge in combating tangle bloat if it is ever to achieve hundreds of transactions per second, whereas Ardor has largely solved this problem.

Finally, it’s worth noting that a proposal on the Ardor roadmap would delegate child chain transaction processing to dedicated subnets of the network. This would potentially achieve a computational gain similar to IOTA’s “swarming” proposal, possibly allowing similarly high throughput.

Final Thoughts

If you’ve read this far (thank you!!) and were already familiar with IOTA, then you’ve undoubtedly noticed that I left out a lot of details, including its homebuilt hashing algorithm, the deliberate flaw in this algorithm that Come-from-Beyond included as a copy-protection mechanism, the use of ternary encoding, and the mysterious Jinn processor that will provide hardware support for IOTA in IoT devices. In the course of my research, I’ve formed fairly strong opinions on all of these things, but I was reluctant to share them here for two reasons.

First, I don’t have sufficient information to make objective statements on these issues. I’m not a cryptographer, and I know next to nothing about ternary computing or Jinn. The best I could do would be to offer subjective judgments of the design decisions the IOTA team made, but that would have simultaneously weakened the focus of this article and opened it to criticism from people who have made different subjective judgments.

Secondly, and more importantly, I’m more interested in the fundamental concepts behind the tangle than IOTA’s specific implementation of it. Regardless of whether IOTA succeeds or fails, the tangle is a beautiful idea and deserves all the attention we can muster.

So what can we say about the tangle, then? While I’m positively enamored with the elegance of its design and the nuances of its consensus mechanism, at the end of the day I’m afraid I’m quite skeptical of its suitability for the Internet of Things. Drop that aspect, increase the PoW requirement by several orders of magnitude, and find a way to tie the PoW threshold to the monetary value of the network without cutting ordinary users off from their funds, and I think the tangle has tremendous potential as a distributed ledger.

The last missing piece is how to cope trustlessly and efficiently with bloat, a problem that Ardor have solved extremely well. Perhaps somebody will find a way to combine the best elements of both designs at some point in the future. A lot could happen by then, especially in cryptoland.

P.S. – I promise the next article will be shorter. 🙂

Ardor vs. the Competition, Pt. 2: NEM/Mijin/Catapult

This post is part of a series that compares Ardor to other blockchain projects with similar features or goals. You can find the previous posts here:

This week I studied NEM, a public blockchain similar to Nxt in many ways. As I’m primarily interested in each blockchain project’s approach to scaling, I also researched Mijin, a version of NEM for private blockchains, and Catapult, a rewrite of Mijin which promises large performance gains and which will also be incorporated into future releases of NEM.

NEM

Although NEM’s core developers abandoned their initial plan to start NEM as a fork of Nxt, choosing instead to start the project from scratch, NEM and Nxt are still fairly similar. Like Nxt, the NEM platform provides a predefined set of allowed transactions which applications can use as building blocks to create more complex features, as opposed to using a low-level scripting language to construct transactions, like Bitcoin or Ethereum.

Both platforms support a variety of “blockchain 2.0” features, like sending messages, creating and transfering assets, and sending transactions requiring the approval of multiple accounts (m-of-n multisig). And both platforms expose their functionality through HTTP-based APIs, so developers can use virtually any language to write applications for them.

Despite these similarities, NEM also has some notable differences compared to Nxt.

Perhaps the most fundamental one is its novel consensus algorithm, called proof-of-importance. This algorithm is similar to proof-of-stake, except the probability that an account may harvest (i.e., forge) the next block depends not only on its stake of XEM, which is the native coin on NEM, but also on how recently it has transacted with other accounts and how much XEM was exchanged. Accounts that hold a large stake of XEM and which transact frequently and in high volume harvest more blocks than accounts with less XEM or accounts which only rarely transact.

The authors of the NEM Technical Reference argue that, compared to proof-of-stake, the proof-of-importance algorithm gives somewhat less weight to the wealthiest accounts when determining the right to forge/harvest the next block (Section 7.8). Proof-of-importance is also central to NEM’s spam filter, which requires that an attacker not only control a lot of accounts, which is easy to do, in order to spam the network with a large number of unconfirmed transactions, but also to hold a large stake in each account and transact frequently with other high-importance accounts.

In my view, another main difference between NEM and Nxt is the extent to which each platform’s “blockchain 2.0” features are integrated directly into the API. For example, NEM’s assets, called “mosaics,” share several features with the Nxt Monetary System’s currencies, but NEM does not have a built-in decentralized exchange for mosaics. (As a side note, the NEM Foundation has contracted with Blockchain Global to create a traditional, centralized exchange featuring mosaic-based ICO tokens.) Similarly, while you could certainly build a decentralized marketplace on top of NEM where users could buy and sell goods and services, NEM does not have such a marketplace built into its API the way that Nxt does.

Finally, one subtle but very important difference between NEM and most other blockchains, including Nxt, is the way that it handles multisignature transactions. Instead of allowing any account to generate a multisig transaction, NEM introduces the concept of a multisig account and requires that all multisig transactions originate from such accounts. Any co-signatory on the account can initiate a transaction from it, and the transaction is only executed if a sufficient number of the other co-signatories approve it.

At first this might appear to be a limitation, since it requires a separate multisig account for each set of co-signatories a user wants to cosign with, but it has two key advantages: the multisig account is a full account, capable of receiving payments, messages, and mosaics, for example; and co-signatories can be added and removed, so custody of the multisig account can be transferred. It is possible to create a “1-of-1” multisig account, i.e., an account with a single custodian who can transfer it to a different custodian if desired. In this way, multisig accounts on NEM can act like transferable containers for XEM, mosaics, and messages.

One particularly impressive application of this concept is a notary service built on NEM called Apostille. With Apostille, the process of notarizing a document looks like this:

  1. Hash and sign the name of the document.
  2. Create a multisig account for the document derived from the resulting signature.
  3. Hash and sign the contents of the document.
  4. Send a message containing the result to the document’s multisig account.

Note that the last step also attaches a timestamp to the document, since the transaction that transfers the document’s signed hash to the multisig account is recorded on the blockchain.

As an example of a potential application of Apostille, the authors of the white paper consider a case where the notarized document is a car title. Ownership of the car can be transferred by changing co-signatories on the multisig account that contains the title; messages describing maintenance and repairs can be sent to the multisig account to record the car’s service history; and mosaics issued by governments or insurers could attest to payment of fees. In this way, the multisig account represents both the car itself and the history of other accounts’ interactions with it.

Anyway, that’s quite enough about NEM. Next, Mijin.

Mijin

At a high level, Mijin is a version of NEM that three of the core NEM developers and a company called Tech Bureau developed as a private, permissioned blockchain product. Like any private blockchain–and in contrast to NEM, which is public–a Mijin blockchain is owned and controlled by a central authority, such as a company.

This isn’t the place for a full debate about the utility of private blockchains, but as Mijin and Catapult are an important part of the NEM ecosystem, please indulge me for a minute. In my opinion, the more “private” a private blockchain becomes, the less useful it is. While I can see a case to be made for “consortium” blockchains, where a handful of independent organizations who don’t necessarily trust each other cooperate to secure the network against abuses by any one member of the group, I have trouble seeing the value in a blockchain controlled by a single authority. In my view, a blockchain without trustless consensus is basically just an extremely slow, extremely inefficient database.

I know there are plenty of people who disagree with me, though, so for the remainder of this post I’m going to assume private blockchains have value and that there is a market for them, especially in financial services, which seems to be the main industry that Tech Bureau intends for Mijin to serve.

There is not nearly as much information about Mijin available on the internet as there is about NEM, but I did learn some interesting facts that hint at its potential. For one thing, although Mijin and NEM are completely separate projects, Mijin does share the NEM API (or at least the two APIs overlap substantially), which suggests that it will be relatively easy for developers to write applications that run on either platform. The common API might also facilitate interactions between Mijin chains and the public NEM chain, but I haven’t found any information about the details of those interactions.

Additionally, the Mijin website states that Mijin will support smart contracts, though the Catapult white paper seems to slightly contradict that statement when it says, “the approach here is to make the smart contract an external component, whether centralized (i.e., status quo with existing systems) or decentralized. The outputs of these smart contracts will then enter their transactions into the ledger through a secure transaction process.” To me, this implies that the contracts themselves will be neither stored on the blockchain nor executed by all nodes on the network.

Speaking of Catapult…

Catapult

Catapult is a rewrite of Mijin with a focus on increasing the rate at which transactions can be confirmed. Judging from the white paper (linked above), the first deployments of Catapult will be at banks and other financial institutions, where the author envisions it will replace patchworks of “disjointed monolithic systems” that he says are commonly used today. Eventually, the developers also plan to integrate Catapult into NEM to facilitate scaling the public blockchain as well.

Like Mijin, Catapult is currently closed-source and many technical details are not public. I was able to find some good information digging around the NEM blog, though, especially in this thread by one of the developers.

Catapult divides the work that the network does among three types of nodes:

  • P2P nodes, which add new blocks to the blockchain and maintain consensus about its state;
  • REST nodes, which present client applications with all the features they can use from the Catapult API; and
  • API nodes, which, like P2P nodes, store the blockchain and can read directly from it (I think), but which do not add blocks to it. These nodes serve data to the REST nodes to fulfill client applications’ requests.

This breakdown appears to roughly correspond to the three-tier architecture commonly used for web applications, where the blockchain (P2P nodes) is the database, the REST nodes are the front-end, and the API nodes handle the business logic of interpreting and interacting with data in the database.

If this analogy is correct, then presumably the goal of this architecture is to allow each tier to scale independently. Especially for a private blockchain, the optimal number of P2P nodes used to establish consensus might be much smaller than the number of REST and API nodes required to handle all of the requests that applications send to the network. Delegating these responsibilities to separate nodes on the network should allow nodes of each type to be added or removed as needed to optimize performance.

Apart from this new architecture, Catapult also makes some other optimizations to improve performance. Whereas Mijin and NEM are written in Java and use HTTP for communicating with full nodes, Catapult is being written in C++, and communication between at least the API nodes and REST nodes uses full-duplex sockets (via ZeroMQ), potentially allowing for lower latency than HTTP.

A performance test of three Catapult nodes located in the same datacenter and configured to service requests from 10.8 million accounts showed that the network was able to process just over 3,000 transactions per second. It isn’t completely clear from the press release, but it sounds like each of the three nodes in this test played all three roles: P2P, API, and REST. Confusingly, the accompanying diagram appears to refer to API nodes as “blockchain data ingestion servers” and to REST nodes as “API gateway” servers.

Compared to Ardor

How does NEM compare to Ardor, then?

Really, there are (at least) two separate questions: how do NEM’s features compare to Ardor’s features? And how does NEM’s approach to scaling compare to Ardor’s approach?

Since Ardor (the platform, not the parent chain) will support all of Nxt’s current features, the comparisons I noted above between NEM and Nxt apply equally well to Ardor.

In particular, Ardor’s child chains will have at their disposal a somewhat larger variety of built-in transaction types that support a richer set of features.

For example, NEM does not natively support a peer-to-peer exchange for mosaics, dividend payments to mosaic holders, transactions conditioned on votes by mosaic holders (or most of Nxt’s phased transaction types, for that matter), account properties, a decentralized marketplace, or anything like Nxt’s shuffling and alias systems.

Ardor’s parent-chain/child-chain architecture will add some extra functionality, too.

In particular, users will be able to exchange different child chain tokens for one another directly, without first converting to ARDR. This will be especially useful on pegged child chains, where users will be able to trade dollar-pegged coins directly for bitcoin-pegged coins (for example), whereas on NEM, somebody holding a dollar-pegged mosaic would have to sell it for XEM, then buy a bitcoin-pegged mosaic.

These differences notwithstanding, NEM still offers a rich set of features that application developers can use in interesting ways. Perhaps the best example is Apostille’s creative use of NEM’s unique multisig accounts. I’m not sure how easy it would be to replicate that kind of functionality on Ardor.

[EDIT]: Lior Yaffe, core dev and co-founder of Jelurida, has the following comment:

With NXT this can be achieved by issuing a singleton asset for each license registration and sending it between accounts.

On the question of how to scale, the two platforms differ much more dramatically.

Catapult’s approach, which NEM will eventually incorporate, is twofold: a new three-tier architecture to distribute the network’s responsibilities among three specialized types of nodes; and a series of application-level optimizations, e.g., using C++ instead of Java. We will need to defer judgment of the latter approach until additional benchmarking tests are available, but we can still cautiously speculate about the implications of the new architecture.

The biggest advantage seems to be for private blockchains, where the owner can fine-tune the quantities of the three types of nodes and the topology of the network to optimize throughput. Moreover, in such a context, blockchain bloat isn’t as severe a problem as it is for a public blockchain since companies can easily dedicate terabytes of storage on their servers to storing the blockchain.

The improvement in NEM’s performance with this new architecture, on the other hand, is much harder to predict. It is not clear whether each peer on the network would have to run all three services (P2P, API, REST) or just one of the three. In the former case, the scaling advantage to the new architecture would presumably be lost. In the latter case, the classic trade-off between speed (fewer P2P nodes, more API and REST nodes) and security (greater fraction of P2P nodes) would remain. And since nobody could control the number of each type of node on a public network, the question of what the optimal balance is would be moot.

In contrast, Ardor’s design does not try to achieve the highest possible throughput, at least initially. Rather, Ardor’s main scaling goal is to greatly reduce the size and rate of growth of the blockchain. It does this using a unique parent-chain/child-chain architecture, where all nodes on the network validate all transactions, but only those belonging to accounts holding the parent chain coin (ARDR) forge. Since the child chain coins can’t be used to forge, the child chains’ transaction history is irrelevant to the security of the network and can be pruned away.

It is worth noting, however, that computational scaling is on the Ardor roadmap.

Specifically, it is possible that child chain transaction processing will be delegated to separate subnets of the Ardor network in the future, allowing most nodes to ignore most transactions.

Conclusion

Ardor and NEM both offer rich, largely overlapping sets of features.

Overall, my impression is that developers will probably be able to build similarly complex applications on either blockchain with comparable ease. In that sense, the two platforms are direct competitors.

In their approaches to scaling, though, Ardor and NEM are quite different.

While Catapult will likely achieve a significant improvement in the rate that private blockchains can confirm transactions, I am somewhat more skeptical of the performance improvement that can be achieved on a public blockchain like NEM using the same approach.

Ardor, on the other hand, does not attempt to address the computational scaling problem (for now), but has found a very effective solution to the problem of blockchain bloat.

I suppose time will tell whether computational scaling or blockchain bloat is ultimately going to pose the biggest long-term problem for blockchain tech, and time will also tell whether either platform has found an adequate solution.

IGNIS ICO Report 7

Today the 3rd batch of Round 3, with 25 M JLRDA tokens, became available for sale. At the time of writing, there were still JLRDA tokens available.

Finally – some would say – the IGNIS ICO hype calmed down a little. Finally, it is possible to attend the ICO and buy JLRDA without running a full node client, placing several buy-orders in advance, or having to figure out the most advantageous peer settings and transaction fees in order to get a chance to win the over-participated lottery for future IGNIS tokens on the Ardor Blockchain Platform.

ICO: Jelurida [ID 823491988455668070]

Live data from the Nxt blockchain

peter2615

As someone said on the forum in the ICO thread:
In round one 1 NXT = 4500 Sat. 1 JLRDA = 0.4 NXT = 1800 Sat.
In round [three] 1 NXT = 2000 Sat. 1 JLRDA = 0.76 NXT = 1520 Sat.

So, the guy who ran away with all the JLRDA in the first few rounds did not get such a great deal afterall …

Live data from the Nxt blockchain

Either the whale investors

  1. Gave up (as they attended on equal terms with everyone else)
  2. Believe that 1 IGNIS token will be worth less than 0.76 NXT at the current NXT price
    (0.76 NXT = 0.07 USD or 0.0000162252 BTC)
  3. Believe that the price of NXT will rise a lot in the future – keep in mind that by holding NXT you get 0.5 IGNIS per NXT that you own at the snapshot (Q4 2017) and you get to keep your NXT
  4. Decided to invest in ARDR instead of JLRDA
  5. Do not even know about Jelurida’s work and the IGNIS ICO

Let us take a look at the three tokens in play, and you can choose your path to success by choosing which one best suits your interests and needs.

NXT

Nxt launched in 2013 as the first 100% Proof-of-Stake (PoS) blockchain ever and has run stable ever since. Over the years Nxt was optimized with built-in smart contracts that anyone can use “as is” or use them to build their decentralized applications with – without risking their investors’ money or the security of the blockchain, as no 3rd party code is added to the blockchain. Nxt’s smart transactions are rigorously tested in production and can be accessed using the Nxt API, which supports over 200 request types. Nxt is coded in Java, the leading industry standard language for corporate applications. The Nxt platform is open source for its open and supportive community. Nxt is called the “Swiss army-knife” of crypto, undervalued in the markets, and technically ahead of the competition.

With the new JPL license, owners of NXT are entitled to receive 10% of tokens from clones of Nxt.

https://nxt.org
https://nxter.org/tutorials
https://nxter.org/newsletters

IGNIS

Ignis will be the first child chain on Ardor. Ignis will have all of the features of Nxt, except for forging – it will be secured instead by Ardor’s main chain. Users of Ignis get UNRESTRICTED ACCESS to all existing and future Ardor child chain features. Do not expect unrestricted access from any other child chain in the ecosystem, as their creators may restrict those. Ignis will constantly be pruned (no blockchain bloat – means: globally scalable) and will feature cross-chain transactions, e.g., token and asset trading, and access to custom features on any other child chain. JLRDA, the non-transferable token sold in the ICO, represents the monetary unit and transactional token of Ignis, IGNIS, 1:1. JLRDA tokens will convert to IGNIS automatically at the Ardor Genesis Snapshot.

https://jelurida.com/ico
https://www.nxter.org/tag/ignis-ico/
https://www.jelurida.com/ardor-nxt-feature-comparison

ARDOR

Ardor is Nxt 2.0 and is best described as a Blockchain-as-a-Service (BaaS) platform, currently running on testnet. Ardor is the main chain that will secure, bundle and forge all transactions on the network of child chains. Ardor will make the features of Ignis available to other child chain creators, but restrictions can be placed if certain features are not desired, such as shuffling of tokens, the unrestricted decentralized marketplace or the unregulated asset exchange. Child chains will have their own operational token so users will not have to buy “gateway tokens” such as NXT, ARDR or ETH to use them. Child chains will be prunable and will not have to be bootstrapped, as they are secured by Ardor. Child chains can be spawned and customised with help from Jelurida, but the ability to create new chains will eventually be integrated into the software as a DIY module. For those that like account and ID regulations and restrictions – Ardor is the place to be. For those that like to forge all child chain fees – Ardor is the place to be.

https://www.ardorplatform.org
https://nxter.org/ardor-blockchain
https://www.jelurida.com/sites/default/files/JeluridaWhitepaper.pdf


 

 

Live data from the Nxt blockchain

ARDOR introduction video

Q4 2017

  • Ardor mainnet launch
  • Migration of ARDR balances from the Nxt blockchain asset to the Ardor Genesis block
  • Spawn of the IGNIS child chain based on NXT and JLRDA balances
  • Spawn of Bitswift child chain with 10% share drop to IGNIS holders
  • Spawn of BTC, EUR, and USD pegged child chains backed by 3rd party business entities

ICO’s are hot right now, and the choice is hard if you have money to invest. The choice is entirely up to you – supporting any chain supports Jelurida, the company that owns the IP for the above tokens.

Right now, the JLRDA tokens are for sale on the Nxt blockchain and will be automatically swapped for IGNIS tokens on the Ignis child chain when Ardor and Ignis are launched together in Q4 2017.

#nofomo

You need NXT to buy JLRDA. The most secure and the recommended way to buy JLRDA is from the IGNIS Token Sale link in the NRS Client, currently running V1.11.9.

You can use Jelurida’s online Nxt node or download and run the client locally – as light (no blockchain download) or full node. You can also use Nxt OFFLINE to create cold storage accounts to buy IGNIS.

JLRDA tokens cannot be transferred or traded until Ardor is launched – do not fall for scams.

Stay tuned for more up-to-date coverage on the ICO. We will explain in more detail about Jelurida, Ignis, Ardor, and everything else that is pertinent to this ICO. We won’t give trading advice.

Follow us on Twitter for breaking updates. And please help us grow as we continue to provide our readers with excellent and focused coverage on the ever growing blockchain space by rewarding us for our efforts – Donation address: NXT-TK9J-MEKH-MUP9-HFCH2.

This article is for educational purposes only. It is advisable never to invest more than you can afford to lose.

IGNIS ICO Report 6

Round 3 of the IGNIS ICO is underway, and the first batch has already sold out. Interest is high in this ICO, and that is good news for Jelurida and the entire Nxt community. The third round of the crowdsale is divided up into four offers of 25 M JLRDA each, all priced at 1 JLRDA for 0.76 NXT.

JLRDA batches will be sold according to the following schedule:

Sat, Sep 9th between 06:45 - 07:15 UTC
Sun, Sep 10th between 18:45 - 19:15 UTC
Tue, Sep 12th between 06:45 - 07:15 UTC
Thu, Sep 14th between 18:45 - 19:15 UTC

The exact time within each 30-minute interval is randomly determined. Jelurida reserves the right to modify the above schedule in case of circumstances beyond its control.

The IGNIS ICO is, in essence, a barometer of the public's interest in the Nxt and Ardor Platforms. With Ardor due to launch in Q4 of this year, Jelurida needs to know how to split up their limited dev resources. The funding raised by Jelurida, which owns the IP for Nxt / Ardor / Ignis is directly going towards actively developing Nxt. So far Jelurida has procured enough funding to actively support Nxt for, at least, the next three years.

The ICO so Far

The highlights of Round 1 in early August were the whale "MAAC" eating up the entirety of the first couple of batches. He accomplished this through clever use of the Nxt blockchain protocols. Within 48 hours Jelurida senior developer, Lior Yaffe, released a patch to prevent similar occurrences: NRS client V1.11. 7. The Nxt platform now allowed for scheduling transactions up to 24 hours in advance.

Like the first round, Round 2 sold out in seconds. The current and most stable NRS client is V1.11.9.

So far every round of the ICO has sold out before the JLRDA sell offers had posted! Since the demand for the IGNIS ICO is still higher than the supply, the way to have a shot at getting JLRDA is to schedule your buy transaction in the NRS client 24 hours before the batch is officially for sale.

REMEMBER - Jelurida is the ONLY source of official information about the IGNIS ICO. All info here is directly provided by Jelurida. 


Ignis ICO Report 8

By apenzl | 03/11/2017

BTC is on a bull run, to put it gently. Anyone watching crypto charts and price indexes these days see the value of BTC (Bitcoin) skyrocketing up up up; resulting in most altcoins declining in value when pegged against BTC. This story also applies to NXT and ARDR, yet ARDR does extremely well in terms of … Read more

IGNIS ICO Report 7

By apenzl | 13/09/2017

Today the 3rd batch of Round 3, with 25 M JLRDA tokens, became available for sale. At the time of writing, there were still JLRDA tokens available. Finally – some would say – the IGNIS ICO hype calmed down a little. Finally, it is possible to attend the ICO and buy JLRDA without running a … Read more

IGNIS ICO Report 5

By apenzl | 30/08/2017

Is your bid order in place? Popcorn ready? Tomorrow, on Thursday, Aug 31st between 18:45 – 19:15 UTC, the last batch of Round 2 in the IGNIS ICO is offered. That’s the last of 4 batches, each counting 20M JLRDA tokens. The price is 0.55 NXT per JLRDA – the token that will swap 1:1 … Read more

IGNIS ICO Report 4

By apenzl | 24/08/2017

And so, the hunt for JLRDA is about to resume. Round 2 of the IGNIS ICO will kick off Aug 26 between 06:45 – 07:15 UTC The price will be 0.55 NXT per JLRDA, with 80M JLRDA tokens for sale in this round. Anyone who did their due diligence will know: Ignis will be launched with … Read more

IGNIS ICO Report 3

By apenzl | 10/08/2017

Only 1 batch left of Round 1! UPDATE: no JLRDA left from Round 1!  Round 2 will begin on August 26. And so, here’s a re-cap, as the hunt for cheap JLRDA continues… Early NXT investor ‘MAAC‘ has taken much of the limelight as he overruled “normal” participants by using the advanced features of the … Read more

IGNIS ICO Report 2

By apenzl | 07/08/2017

Did you hold your breath? Never mind, the second 5M batch of the IGNIS ICO got snatched by MAAC the Whale. And also most of the third. But look at this now: Live data from the Nxt blockchain 69 new buyers got their hands on JLRDA  – no ninja tricks, no bots, just by using … Read more

IGNIS ICO Report 1

By apenzl | 05/08/2017

The long awaited crowd sale of the IGNIS token has begun. For sale are 440,000,000 Jelurida tokens (JLRDA) out of 1,000,000,000 total. The Nxtchat.slack has been buzzing for weeks with anticipation and discussions of how to get your hands on these JLRDA tokens and this article contains some important information pertinent to your investing decisions. … Read more

Ardor is about to launch, and the revolutionary parent - child architecture will solve many blockchain problems. Follow us on Twitter for important breaking updates during the week as they happen. Learn more every Monday with the release of the weekly Nxter Newsletter. We explain in more detail about Jelurida, Ignis, Ardor, and everything else that is pertinent to this ICO. Stay tuned and stay informed, dear readers. See you back here next week!

Help us grow and help us continue to provide excellent and focused coverage on the ever growing blockchain space by rewarding us for our efforts. Donation address: NXT-TK9J-MEKH-MUP9-HFCH2.

Thanks to https://twitter.com/lepych10 for beach art / NXT>ARDR img  🙂

Ardor vs. the Competition, Pt. 1: Lisk

I recently decided to start a series of posts that compare and contrast Ardor with other blockchain projects that appear to have similar goals or features. Roughly each week, I'll pick a project whose scope overlaps at least a little with Ardor's, study its technical documentation, and post a summary of my findings here for you to critique.

This week, I've been reading about Lisk.

Lisk

In a nutshell, Lisk is a platform for developing decentralized applications (dapps) that run on sidechains anchored to the Lisk mainchain. It uses a delegated proof-of-stake (DPOS) consensus mechanism to secure the mainchain, while sidechains are each responsible for their own security (sort of, but see the description of the delegate marketplace below). The protocol uses a set of predefined transactions, rather like Nxt and Ardor, as opposed to a low-level scripting language like Bitcoin or Ethereum.

Before I get into the details, I should start by saying that Lisk is definitely in an early stage of development. The team is currently in the middle of rewriting the Lisk SDK, which will support sidechain development, and is continuously refactoring Lisk Core, which is the full node.

With the code in flux, some important architectural questions, particularly about sidechains and how they will interact with one another and with the mainchain, do not appear to have been settled yet. On the other hand, I had some difficulty finding a current, authoritative source of technical information about Lisk, so what I present here might be out of date. The best information I could find was in the wikithis article by one of the co-founders, the roadmap, and these YouTube videos. None of the first three sources are recent, unfortunately, and even the videos don't go into much depth (though I admit I haven't watched all 6+ hours of them). If you've found better references, I'd be grateful if you could send them my way.

The marketing buzz surrounding Lisk seems to focus on the SDK, the goal of which is to make it easy to build, deploy, and secure a dapp running on a customizable blockchain. The devs wrote the SDK in JavaScript because they want to make Lisk accessible to as wide an audience as possible, and they also wrote the backend in JavaScript (Node.js) because...well, I guess I'll never understand why people insist on using JavaScript on the backend. 🙂

But clearly, ease of developing and deploying a custom blockchain is not the only goal of Lisk. If it were, then what purpose would the mainchain serve? You might as well clone Bitcoin or Nxt if all you want is a good starting point for building your own blockchain.

The mainchain/sidechain architecture is the real distinguishing feature of this platform. As far as I can tell, the mainchain serves at least three important functions:

  1. The Lisk API will allow deposits of LSK on the mainchain to be transferred to and from sidechains. With two such transactions, it will be possible to send LSK from one sidechain through the mainchain and to another sidechain. Unfortunately, according to the article by one of the co-founders linked above, it sounds like transferring LSK onto a sidechain will require sending it to the sidechain's owner, which obviously requires some degree of trust. To avoid this problem, it will be possible to create sidechains that use their own forging tokens instead of LSK. This token would then need to be traded for LSK in order to transact through the mainchain with another sidechain. Alternatively, it might be possible for one sidechain to transact directly with another sidechain without going through the mainchain, but the developers are still researching how this would work.
  2. Eventually, the team plans to build a "delegate marketplace" where delegates who are not securing the mainchain can offer to secure sidechains and are paid "either by the [sidechain] application owner or its users." Again, the details are a little fuzzy, but there seems to be a lot of value here: presumably the Lisk network is already far larger than a typical brand new blockchain network, and the delegate marketplace gives sidechains an "off-the-shelf" set of nodes that they can use to secure themselves in their infancy.
  3. Some nodes on the network (not sure which ones) will periodically hash sidechains and store the hashes on the mainchain as a "basic validation of sidechain integrity." I haven't been able to find any details about how this mechanism will work, though.

Apart from these functions, and from the obvious role it plays in transferring LSK between accounts, the mainchain itself doesn't seem to have any other intended uses. All of the business activity is supposed to occur on the sidechains.

Compared to Ardor

How does this architecture compare with Ardor's parent chain and child chains?

Maybe the most obvious difference is that each sidechain must have its own set of nodes to secure it, whether these are provided by the sidechain creator, the users, or eventually the delegate marketplace.

With Ardor, in contrast, every node on the network validates child chain transactions, but only accounts holding ARDR forge. The fact that accounts holding child chain tokens don't forge with them means that it doesn't matter how small child chains are or how unequal the distribution of tokens on them is; they are all just as secure as the parent chain.

One additional note about Lisk is that, until the delegate marketplace opens, sidechain creators choose the nodes that forge on their chains, which seems to require that users place a great deal of trust in them. On the other hand, the team has also suggested that Lisk will be flexible enough to allow sidechains to use an entirely different consensus algorithm, like proof-of-work, so it seems that sidechain creators wouldn't determine which nodes secure the chain in that case.

There are also plans to allow existing sidechains to switch consensus mechanisms even after they launch, but again I haven't been able to find details.

Clearly, both Lisk and Ardor intend to offer scaling advantages over traditional blockchains. With Lisk, the computational scaling advantage is obvious, since each forging node validates only the transactions on a single blockchain, either the mainchain or a sidechain. The reduction in required storage space (i.e., blockchain bloat) is less clear, though. Compared to Ethereum, say, it's obvious that for a similar level of total activity, the many chains in the Lisk ecosystem will each grow more slowly than the single Ethereum chain, simply because sidechains will not store each other's data.

Compared to Ardor, though, the storage savings would be modest. Ardor's parent chain will grow at a similar rate to the Lisk mainchain--as both will store only hashes of sidechain or child chain data instead of the data itself--but on Ardor the child chain data will be pruned away, eliminating the blockchain bloat problem that Lisk will still have on each sidechain.

Conclusion

What, then, should we make of Lisk? Honestly--and I'm very disappointed to write this--I think it's simply too early to tell. Too many important details have yet to materialize:

  • Will it be possible to convert one sidechain's token directly to another sidechain's token without converting to and from LSK? How?
  • When the delegate marketplace opens, will it be possible for users to elect delegates using sidechain tokens? Or will they have to use LSK? Or will sidechain owners maintain control over which delegates forge?
  • What will Lisk do with the hashes of sidechains that are stored on the mainchain? Will it be possible to roll back recent transactions on a sidechain to "restore" it to the state it had when it was hashed? If so, will there be some time after which this will not be possible, so that the sidechain can still be considered immutable?
  • Will the Lisk SDK provide some clean mechanism for changing the consensus algorithm on an existing sidechain? I'm not sure what this would look like.
  • What happens if a sidechain that uses LSK forks? Obviously, the LSK tokens on both resulting sidechains cannot be simultaneously backed by the same LSK reserves on the mainchain. I would assume the sidechain creator effectively gets to choose which chain is the "real" one, since he or she is the one holding the reserves on the mainchain, but I don't know for sure that this is correct.
  • Depending on how Lisk will support transactions directly between sidechains, this same concern could require additional trust between sidechain creators. In particular, if sidechain creators must hold reserves of each other's tokens to enable cross-chain transactions, which seems like one plausible way to do it, then a fork in one sidechain could give the other sidechain's creator some influence over which branch of the fork is honored. Moreover, if the forking sidechain transacts with several other sidechains, each of which hold reserves of the split token, then the situation could get ugly pretty quickly.

In my opinion, the most important advantage Lisk has over most blockchain platforms, including Ardor, is that it will accomplish a natural computational scaling by segregating each dapp onto its own blockchain. If, in addition, sidechains will be able to transact seamlessly and trustlessly with one another, then it seems like the design has immense potential.

If we're making the assumption that the Lisk team will successfully implement all the features required to make this happen, though, then we ought to grant Jelurida the same courtesy and assume that they'll be able to carry out their own scaling plans. In particular, one potential improvement on the Ardor roadmap is to confine child chain transaction processing to dedicated subnets of the Ardor network. It seems to me that this would accomplish a similar computational scaling to Lisk, while preserving Ardor's substantial advantage in reducing blockchain bloat.

In conclusion, Lisk's mainchain/sidechain architecture could potentially help it scale to accommodate a large number of dapps that could interact in interesting ways, but right now there seems to be a lot of uncertainty in the technical details. Ardor's approach is technically quite different but solves some of the same problems, namely blockchain bloat, potentially computational scaling, and the ability to transact easily between separate chains.

It will be very interesting to see how Lisk develops in the next two or three years, but then again, by that time Ardor will have been live for a long time already.

- segfaultsteve

IGNIS ICO Report 5

Is your bid order in place? Popcorn ready?

Tomorrow, on Thursday, Aug 31st between 18:45 – 19:15 UTC, the last batch of Round 2 in the IGNIS ICO is offered. That’s the last of 4 batches, each counting 20M JLRDA tokens. The price is 0.55 NXT per JLRDA – the token that will swap 1:1 for IGNIS tokens when the Ardor Genesis block is created in November 2017. Each and every single batch until now has been sold out in 1 block.

For your reading pleasure, fellow Nxters, let’s quickly touch base with the nxtchat.slack Round 2 experience:

1st batch:

amsi [8:53 AM]
now !!!!!!!!!!!!!!!

martis [8:53 AM]
now!!!!!

gabriel [8:53 AM]
woooo

strophy [8:55 AM]
lol that went fast

josenxt [8:56 AM]
39,703.93 fee in that block? :scream:

lordcameltoe [8:57 AM]
how will I know if my transaction worked?

peter2615 [8:57 AM]
you wait… until next block, to see which offers got filled

As demand is a lot higher than the supply of JLRDA, and as the crowdsale is being held on a decentralized platform, executed under the rules of the blockchain, there were investors that didn’t get lucky. The rules are clear though and people’s different attempts to take advantage of them in the lottery, are transparent as well.

Logan summarizes:

You have to be in the same block, as the JLRDA TX. The capacity of one block is 255 TX. Higher fees are priorized to get in the block and the JLRDA TX will have a fee of 5 NXT. Thats the information you need to make a decision. But there is no right or wrong. Depends on what other people are doing.

riker [10:43 PM]

What happened in practice today was that one account NXT-GJE7-KWDJ-SFWJ-APQ6S tried to game the system by submitting many transactions with 5.2 NXT fee. I’m not sure what was his calculation. What it did is that it delayed the Jelurida transaction to the next block. But we anticipated this in advance and double checked that this does not provide any advantage to anyone.

bitcoinpaul [3:36 PM]

what can we learn from that?
dont bloat the chain with high fees, guys.

Riker

It’s a game theory problem; if everyone submits their transactions with 4 NXT fee, and a single guy with 6 NXT, this guy has an advantage. His transaction, the offer, and as many as can fit from the rest will fit in the block.

If everyone thinks this way and submits their offer with a fee of 6 NXT, all will lose, since their transactions will be included in a block before the sell offer.

forkedchain [5:33 PM]

For the latest JLRDA sell offer, there were 4 completely full blocks, each with 233 TXs, and an additional one with 58 TXs. There were 484 unique accounts that sent TXs in those 5 blocks.

2nd batch:

logan [9:01 PM]
dingdingdingding

vintash [9:08 PM]
yyyyeeees
im in!!!!

mroenne [9:08 PM]
Finally :sunglasses:

vintash [9:09 PM]
yeeeees

gabriel [9:09 PM]
YEAAAAAAH

marenkar [9:10 PM]
Whoa that’s a lot of people who got in this time.

peanut [9:12 PM]
Finally I’m in. I also noticed odd fee sizes, so I used one too just for good luck hehe

eu58 [9:14 PM]
I put 4 NXT for the fee and succeeded!

martis [9:18 PM]
I put 2 scheduled orders and both were filled. Fee was 4.9. No bot, no API, just used “Ignis token sale” link. Previous rounds were unsuccessful for me. As I reached my limit for buying Ignis, I will not participate in other rounds, so more chance for others.

forkedchain [9:53 PM]
I sacrificed a ton of ants just yesterday. ran over a huge ant bed with my mower while cutting grass, AND IT WORKED I GOT SOME JLRDA TODAY!!

logan [10:54 PM]

If i use a node with a comparatively bad connection and you use one which is a few milliseconds faster to publish the Offer TX, the chance that my orders will be filled is nearly zero, isnt it? or at least much worse compared to others

riker [10:55 PM]

Assuming you did everything else right, the more central and well connected your node is you’ll have better chance.

If you are the forger, even better, since then you have no latency.

forkedchain [11:47 PM]

well, it looks like some of my forging pool members were big winners today – all of a sudden my pools forging power has dropped by 5M.

My pool forged the golden block again. I wonder if some pool members had set up my pool as a well-known peer, and that’s why they won.

In lots of my previous attempts, my transaction was in the same block as the SELL, but at an earlier index position in the block. So I didn’t get anything. That means my latency to the forger was really good, but the forger’s latency to the p2p network (network as a whole) whereby that SELL transaction eventually found its way to the forger, was high – its all luck.

Batch 3:

jesus [8:54 AM]
woohhaaaa

thewiremaster [8:54 AM]
Go! https://nxtportal.org/monitor/

josenxt [8:55 AM]
269 unconfirmed transactions!

peter2615 [8:56 AM]
wow… NXT-3CJT-YF6A-VJ5D-DNSWR

gabriel [8:58 AM]
LOL, who was complaining about there not begin enough small transactions

mikevanegan [8:58 AM]
Booya worth getting up 2am. 295,000 JLRDA

peter2615 [8:58 AM]
lol @ NXT-GJE7-KWDJ-SFWJ-APQ6S

shugo [9:02 AM]
omg I finally got in, 4.9 fee
@all with no luck, dont give up (I almost did…)

vizanto [9:03 AM]
Your JLRDA balance 47,840 !!!!!!!!
this was my 3rd try

yelth [9:07 AM]
this was my 15th 🙁

winiusty [12:07 PM]
Hi guys, I bought while sleeping lol
strange feeling

gabriel [3:20 PM]
only problem is the people who couldn’t get in until now and are frustrated, which is totally understandable, but as time goes by, more and more of these people are getting their orders fulfilled, so it will eventually work out just fine, imo

yelth [3:22 PM]
Potentially, but I can just as easily see there as being huge problems with it later on.

potshot-rsa [3:45 PM]
I got my IGNIS at 2017/08/09 8:59:12. I’m in South Africa with a 4Mb/s ADSL connection.

jesus [3:23 PM]

@yelth, i stopped worrying about it. it´s what it is. every other setup would have been stretched to the limit as well. I can see the jelurida marketing machine start working, that´s my main concern. looking at my ARDR and NXT investment, the ICO is a good thing. if i can´t get in cheap, so be it.

And so…. 1 batch left of Round 2. Join nxtchat.slack to ask questions and take part in the discussion. And if you wonder what all the fuzz is about – oh man. The IGNIS whitepaper, and all ICO details can be found here.

These are the stats from the ICO so far:


Live data from the Nxt blockchain

Jelurida AMA on Cryptocopia

For those of you who do not know, a semi-private AMA (Ask Me Anything) session with Jelurida occurred on the Cryptocopia Slack last Wednesday, August 23rd at 22:00 CEST. Jelurida spoke at length with the community, answering many questions about the now-in-progress, IGNIS ICO, Nxt, the blockchain, and much more. Only registered members of the Cryptocopia community could participate, but since we are so well connected we have you covered!

Cryptocopia’s registration-page has been offline ever since they made the AMA announcement, but here we give you an abbreviated, “best of” version that has all the relevant information and highlights that you need to know.

myco [10:02 PM]

Hello, and welcome! The Jelurida AMA is starting now!

Our guests from the official Jelurida team are:

petko

Hi! My name is Petko Petkov. I am a software developer. I’m contributing to NXT since Jan 2015. Then participated in the design and the development of the Ardor platform.

tomi

I am also a software developer, with more than 15 years of experience. I survived the dot-com crash, worked for a few companies in the Silicon Valley, then for a small startup, then became interested in crypto and Nxt in particular a few years ago. Now I am a part of the core Nxt development team.

The other core developer, Lior Yaffe, unfortunately couldn’t attend this AMA tonight as he is not feeling well. Lior Yaffe is a very talented developer and also lately doing a big part of the project management.

kristina

I am not a developer and before becoming interested in cryptocurrencies and blockchain technology I have been working as a legal advisor. I have been following Nxt from its very beginning and when Jelurida was created last year I became an official part of the team because the developers were looking for somebody to take care of organizational, administrative and legal tasks. Now, with the company growing bigger and the upcoming launch of Ardor, I am fully occupied with work and 100% devoted to it.

What will happen with NXT?

Q

myco

I know that we’ve gone through several stages in the transition of NXT to IGNIS and ARDOR.

Could you explain at a high level what is happening with NXT for those who do not know much about it?

kristina

Ardor can be considered Nxt 2.0, because it is being built using proven Nxt technology. The Nxt public blockchain, and software, will continue to exist and be maintained by Jelurida.

There were quite a few technical reasons why Ardor had to be started as a separate platform, and it wasn’t possible to just upgrade Nxt to it.

petko

NXT is an open-source project and POS-based cryptocurrency. We are planning to continue maintaining it, but after all, its the NXT stakeholders who decide whether to use the software we develop. So, there is no actual transition – we had the idea about Ardor and decided to work on it. NXT will continue to exist one way or another. As @kristina explained, there are technical reasons that prevent us from upgrading NXT to Ardor. But we distributed the Ardor tokens to the NXT stakeholders at 1:1 ratio.

Q

dereje

With the development of ardor and jlrda, do you see nxt eventually dying out from lack of support and development?

tomi

We have promised to support Nxt for at least a year, or longer, depending on the funding level obtained in the ICO, and depending on the demand for it. We will also backport features from Ardor to Nxt, if we can hire enough developers to dedicate to that. We expect that Nxt will stay as the stable, well tested and reliable platform. And not all use cases need Ardor with its multiple child chains (which also brings complexity).

kristina

please remember that Nxt is a proven and stable blockchain with a large variety of features, a platform well suited for ICOs for example which is a functionality we plan to further enhance.

Jelurida

Q

myco

What is the development like for Jelurida?

Do you work remotely, or do you have an office where you meet?

tomi

We don’t have an office, working remotely all the time. We do plan to establish a physical office however, depending on the success level of our ICO.

Q

myco

What are the upcoming tasks that the Jelurida team is focusing on in the short term?

kristina

After our ICO is over the snapshot will follow and of course the launch of the Ardor platform.

Q

sanchopansa

How many people are working full-time on the project?

kristina

4 (3 developers and myself) + 2 part time developers.

Q

sanchopansa

How do you plan to generate revenue and when do you foresee to become profitable?

Kristina

We have several possible sources of revenue – licensing of the software for private blockchains, child chain creation, and revenue sharing with businesses that run child chains, consulting, custom wallet creation. Other minor revenue sources are listed in the whitepaper.

We aim to become profitable and self sustainable by the end of 2018.

Q

doubleqp

How much funds do you expect to need until the end of 2018 to survive?

kristina

what we have collected already is enough to survive until the end of 2018.

Q

doubleqp

So what’s your reason to collect even more money?

Kristina

For two reasons: we have a detailed plan how we can utilize the funds up to €50M.

And because we exist in a very fast growing field where our competitors raise/have raised millions which they are using for marketing and because we cannot allow a technology with such a great potential not to succeed.

marenkar

In section V3 of the white paper, (https://www.jelurida.com/sites/default/files/JeluridaWhitepaper.pdf) Jelurida goes over their plan with regards to the amount that they raise (starting on page 36). More funds raised generally means a larger team, more projects, and more business activity.

tomi

Jelurida was established last year as a corporate entity to manage the development of Nxt and later Ardor. Before that, Nxt was developed as a volunteer open source project, without a legal entity behind it. This was problematic when trying for example to license the Nxt software for commercial purposes, and when having to protect the IP behind it.

IGNIS ICO < > NXT ?

Q

myco

When will the IGNIS snapshot take place?

vanbreuk

From https://www.jelurida.com/ico, “The Ardor Genesis Snapshot will be performed at least two weeks after the end of the last JLRDA sale round”. But no exact date has been announced yet.

Q

myco

What happens to the NXT collected in the ICO for IGNIS?

tomi

We will be selling most of the NXT for BTC and fiat, because the purpose of collecting it is to provide funding for the company. We have been very clear about that in the whitepaper. Some amount of NXT, up to 40 M, will be kept by the company.

Q

myco

It seems like selling the NXT you receive in the ICO for BTC and fiat will make the NXT have a much lower value.

Who will be buying the NXT from you? people who want to hold for the IGNIS snapshot?

tomi

We have already sold most of the 24 M NXT collected in the first round, it didn’t crash the price. We expect people who want to participate in the next rounds, or didn’t have a chance to buy in the previous, to be buying this NXT. And at the end, indeed those who want to hold for the snapshot. But even after the snapshot, we believe NXT will continue to have value, and this value will probably become stable, as no major disruptions will happen to it anymore.

kristina

People believed that NXT will lose value after the Ardor asset was launched too, but it didn’t happen… It indeed dropped temporarily but after that it went back up again…

Q

myco

What new functionality is present in IGNIS that was not present in NXT?

tomi

We have a feature comparison table on the website, few things I can think of: asset dividend payments using other assets, or MS currencies, or other child chain coins; asset share increase transaction; smart phasing (a boolean composite of phasing conditions); asset control…

About Ardor

Q

myco

What is the current status of development on ARDOR? When will that be a useable technology in production?

tomi

It is running on testnet now. The multiple child chains framework is implemented and working, you can try it. We are planning a new testnet release some time before the snapshot, which will introduce some innovative features – smart phasing and asset control for example.

The pruning and snapshotting parts of the Ardor design are currently being worked on, and will not be part of the initial release, they will be ready later. See the roadmap on our website for all details.

Q

myco

What mechanisms would cause the rise in price of Ardor? What is Ardor used for?

tomi

Ardor will only be used to provide security for the whole system, it is the token used in the proof-of-stake algorithm. It intentionally has very limited other functionality, as Ardor transactions by design must remain in the blockchain (and cannot be pruned like child chain ones). Having significant Ardor stake will allow users to run forging nodes, and collect fees from all child chain transactions (converted from native tokens to ARDR by their bundlers).

myco

I can understand that value if you get native tokens from staking ardor… but why would I want to get more ardor for staking ardor if there is no additional utility to it besides getting more ardor? It seems circular. what am I missing?

petko

Ardor is like the mining hardware in bitcoin, minus all the wasted electricity

marenkar

For child chains to run, bundlers will need to exist to collect child chain tokens and then pay ARDR to the forgers to process the transactions. Any account can opt to be a bundler as long as they have ARDR and set the rate they want for accepting child chain coins relative to the ARDR paid out to forgers. Transaction fees paid out to forgers will be fixed based on the amount of data processed and/or the type of transaction and have a similar fee structure as that with Nxt ( `https://nxtwiki.org/wiki/Transaction_Fees` ).

In terms of value, assuming all other things held constant, the more child chains on Ardor and the more activity on the child chains on Ardor, the higher the demand for ARDR as the need for it increases to handle the increased demand for transaction processing.

Q

oojacoboo

So Jurlidia needs money to develop Ardor so it can try and sell sidechains to companies?  That the tldr; ?

tomi

Child chains can be useful not only for companies, but for the general public, even when there is a company behind a particular child chain. For example a pegged child chain, with token value fixed to fiat currency, maintained by a 3rd party business who charges commission on entry and exit from the system – but all users than can transact with this currency on the blockchain, denominating their transactions in it. And the Ignis child chain, for which the ICO is being conducted, will always remain decentralized and accessible to everyone.

kristina

not only creating child chains, but also private blockchains – it depends on the use case

and please note that the Ardor child chains are not side chains. The difference between them is explained in our Whitepaper.

Link to white paper – `https://www.jelurida.com/sites/default/files/JeluridaWhitepaper.pdf`

Link to page about side chains vs child chains – `https://www.jelurida.com/child-chains-and-side-chains`

Q

sanchopansa

What are the major industries/verticals that you are hoping would be using NXT?

tomi

Banking and financial sectors, asset issuance and trading, voting (including shareholder meeting voting), crowdfunding. We have been in talks to several banks that are testing internally our technology, but since this is under NDA I can’t mention names until it becomes publicly known.

Q

sanchopansa

Do you have any commercial partnerships/deals that you can talk about?

kristina

The ones not covered by NDAs – we have partnerships with companies/projects like TLVC, Beecrypt, Bitswift, Sigwo Technologies and quite a few others to be announced soon…

Q

sanchopansa

If I understand correctly, you’re in the blockchain-as-a-service space so that would make Stratis, Lisk, Ark and maybe to some extent Ripple your competitors. Why would any business use Ardor instead of these other options?

tomi

We believe that our parent – child chain architecture is currently unique in the blockchain space, and it opens the door for even more use cases and a greater interoperability between child chains. It also solves the blockchain bloat problem – which I don’t believe those other platforms have a solution for. Ardor is based on the tested and stable Nxt codebase, and has a very rich feature set which will be carried over to it from Nxt.

Price speculation

Q

myco

Why do you think that NXT has been left behind in price, relative to new coins coming out in the past year?

marenkar

There’s quite a lot of reasons because Nxt has existed for quite a long time, such as a lack of a proper team, which Jelurida now fills, a lack of funds, which this ICO now aims to address. Also it being the first Proof of Stake platform during a time when everyone wanted to mine held things back a bit. I made a long post about it if anyone’s interested – `https://www.reddit.com/r/NXT/comments/6m2tyd/why_did_nxt_never_catch_on/djyjxa6/`

Q

myco

What are you going to do differently with IGNIS to make a token that people want to hold?

Or will you focus on making money through corporate consulting use cases?

Petko

My personal opinion is that there is no need to do something special with IGNIS in order to differentiate it from the other child chain tokens. Same like NXT – everyone is free to clone NXT and start another blockchain and token (and there are many clones existing), but the NXT token only one

Q

oojacoboo

And why would I want to own any JLRDA tokens?  What value do they have, since this is a funding model for Ardor…

thewiremaster

The JLRDA MS tokens represent the IGNIS tokens you will get at Ardor launch.

vanbreuk

If a company is funded for developing the platform where your tokens are used, there is a much bigger chance that tokens will appreciate in value. I don’t understand the question.

kristina

Yes, we are selling tokens, that’s right. You may want to fund the development of Ardor because it will be a scalable PoS multi chain ecosystem – it will be the next big step in the blockchain industry

marenkar

Ignis will be the first child chain on Ardor. The Ardor main chain will not have substantial features as it is intended to secure the Ardor network and not be a regularly-used chain. Ignis provides an unrestricted way for users and organizations to utilize the features of Ardor, such as creating an asset or setting up a decentralized poll. Transaction fees to do these transactions will be in IGNIS not ARDR. Other child chains will also have these capabilities but they may set restrictions on them.

The JLRDA > IGNIS ICO

Q

myco

Where can we find the best instructions for how to participate in the ICO? The software used for the ICO is different than the BTC/ETH icos we’ve been participating in lately

tomi

Since we are running our ICO on our own blockchain, it is using the Nxt wallet. It may indeed look different from the BTC and ETH client, but shouldn’t take long to figure out, and especially for the purposes of the ICO we added a separate page – accessible from the Ignis Token Sale link in the header, which really makes it easy.

But do read the instructions on our jelurida.com/ico page, there is also a video showing how to do it, and we plan to post more instructions in a video or pdf too. And remember, only use the IGNIS Token Sale link from the header – do not buy any similarly named tokens/assets/marketplace goods, as unfortunately there have been scammers selling fake JLRDA or Ignis tokens.

Q

myco

What does it mean that IGNIS is “fully permissionless” compared to other child chains

kristina

It means that it is open for everybody to use freely. Other child chains will be associated with a specific use case, a company or an organization behind them. Some of them may want to implement restrictions such as KYC for example….

tomi

Permissioned blockchains is something our enterprise customers ask for, as they want to be able to control who can connect to the blockchain (read access), who can send transactions (write access), and who can give or take such permissions (admin access). Some of this functionality will also be added to child chains that may need it.

Q

lordcameltoe

How will the next IGNIS sale be handled to avoid having whales scoop up the majority of coins before everyone else?

tomi

Everyone has equal chance to participate in the Ignis sale, using our scheduled transaction feature which automatically submits their purchase transaction as soon as the sale offer is posted. And the batch will be split into 4 rounds of 20 M each, again to give users multiple chances to participate.

lordcameltoe

So the technique one person used last time to get most of the tokens has been patched?

vanbreuk

Rather than patched, the Nxt Client now allows for everyone to place a buy order in advance, before the next batch of tokens is effectively placed for sale. So the tactical advantage of that person in the first few batches is not there anymore, since anyone can do it from the client.

marenkar

I’m not 100% sure how it works but it ends up being a lottery of sorts. Some users couldn’t get in, others could. A few users were able to get in even without the scheduler though, but that was rare. Well, at least from what people claimed on Slack.

Thanks for tuning in, dear readers. That was an interesting and informative AMA from Jelurida. They clarified a lot of their plans and continued to bring attention to the IGNIS ICO.

For our ongoing coverage of the ICO, we have our special report series and a weekly Nxter Newsletter, that follows blockchain trends and reports on the last week in the ever growing world of the blockchain. Follow us on Twitter for important breaking updates as they occur. Stay informed and keep reading.

Help us grow and help us continue to provide excellent and focused coverage on the ever growing blockchain space by rewarding us for our efforts: Donation address NXT-TK9J-MEKH-MUP9-HFCH2.

IGNIS ICO Report 4

And so, the hunt for JLRDA is about to resume.

Round 2 of the IGNIS ICO will kick off Aug 26 between 06:45 – 07:15 UTC

The price will be 0.55 NXT per JLRDA, with 80M JLRDA tokens for sale in this round.

Anyone who did their due diligence will know:

Ignis will be launched with all of the features of Nxt, plus more, and it will be created with no restrictions. When Ardor launches, hopefully, November 2017, each JLRDA token on the Nxt blockchain will be swapped for one IGNIS coin in the Ignis Genesis block. 

First child chain, so what? Well, take notice that Ignis will be unrestricted. Ardor child chain creators may choose to disable certain features or set overall rules that not everyone may agree with, as well as possibly control the supply or future distribution of coins used on their child chain. Permissioned child chains can impose restrictions on their users such as KYC/ AML, personal data protection, time-limited data retention, local securities trading laws for asset issuers, etc. But the Ignis child chain will be permissionless, available to the general public, with no restrictions on who can transact with it.

Nxt’s features are described here.
The differences between Nxt and Ardor is available here.

Ignis holders will have easy access to other child chains and benefit from services they provide. Assets, for example, are global, so assets issued using the Ignis child chain can be traded on all other child chains and vice versa. IGNIS can also be traded for any other child chain coin or even ARDR using the inbuilt, decentralized Coin Exchange.

NXT > IGNIS

You need NXT to buy JLRDA, and the NXT price has taken a good beating since Round 1.

The bright side is that the current NXT price makes 0.55 NXT per JLRDA a mighty favorable buy, also compared to the price in Round 1. Not investment advice, just saying, if you’re eager to own JLRDA, now is not a bad time to get in. Long term investors may see every round as a bargain, but do your own due diligence, read the white paper, try Nxt in production, try IGNIS and Ardor on the testnet, and draw your own conclusions. We mean it – you should ask for testnet coins here.

NXT can be bought on exchanges with fiat or BTC or with most cryptocurrencies directly in the NRS Client, using Changelly or Shapeshift.

80M JLRDA in Round 2

In Round 2, 80M JLRDA will be released, divided into 4 batches.
The 4 sell offers will be placed randomly within these 30-minute time frames:

Sat, Aug 26th between 06:45 – 07:15 UTC
Sun, Aug 27th between 18:45 – 19:15 UTC
Tue, Aug 29th between 06:45 – 07:15 UTC
Thu, Aug 31st between 18:45 – 19:15 UTC

To get a fair shot at getting in, ICO participants are recommended to place their orders using Jelurida’s official ICO sales page in the latest client release, NRS 1.11.8. Install, wait for the blockchain to download, place your order and keep the client running until the sale is over. Run the client in full mode.

As many buyers missed out on getting tokens in Round 1, we foresee another battle for tokens coming up. If you miss out on a batch, try the next one. Due to much higher demand than supply, the ICO is set up to run like a lottery to give equal chances for all.

Here’s how to attend:

https://youtu.be/NsRs0vpeNHE

The NXT to invest

When should you get in? Jelurida cashes out their NXT on Bittrex, and also the late BTC rally has been too tempting for some traders to stay in NXT. If you want to crystal ball the NXT market movements, at least be aware of this >

https://nxtportal.org/accounts/9419511406156481100

That is Jelurida’s ICO account. 3M NXT only, out of the first 24M (from Round 1), is left at the time of writing, the rest has been liquidated.

gabriel [8:35 AM]

Jelurida sells the NXT that was raised to fund the future development of Ardor/Ignis/Nxt, so while there is a strong demand for NXT, it is partly offset by the sell pressure from the ICO itself.

This is however great news for the future of all 3 platforms since they will have strong funding.

Jelurida sells the collected funds in batches on the market, to avoid a big dump, which so far seems to work according to the plan.

Plus, as summarised by Riker in nxtchat.slack:

riker [8:54 AM]

Jelurida now has more than enough resources for PR and marketing and we chose Blonde 2.0 and TLVC as our partners since they have a lot of experience in promoting the crypto/crowdsale business.

In addition we are now running full scale marketing campaigns on CMC, Google, Facebook and with anyone who is willing to cooperate and market us. If marketing and PR was indeed our problem for all these years, this problem has been solved.

Afraid of whales?

Sure, the first batches of Round were eaten by MAAC The Whale and rightfully so, due to his study of the Nxt blockchain and tests done beforehand. That said – you should stop worrying.

In case it went over your head, Jelurida solved the problem within 24 hours and released a version of the NRS Client, which not only hacked the hacker but also allowed ICO participants to place their JLRDA orders in advance of the scheduled sales windows.

Use that to buy in, and you’re good. But still, be aware not to place your order more than 24 hrs ahead of time;

When running as a full node, the Nxt software allows you to schedule the JLRDA currency buy transaction in advance, before the JLRDA tokens are offered for sale.

Since transactions by default expire in 24 h, such scheduled transactions must be submitted not earlier than 24 h before the expected time of the offer. Scheduled transactions are kept in memory, therefore restarting the node will also clear them and will require you to re-schedule them again.

Good luck. We will keep you informed.

Want to share your IGNIS ICO experience with us? Leave or comment or email us! Stay tuned and happy hunting!

IGNIS ICO Report 3

Only 1 batch left of Round 1!

UPDATE: no JLRDA left from Round 1! 

Round 2 will begin on August 26.

And so, here’s a re-cap, as the hunt for cheap JLRDA continues…

Early NXT investor ‘MAAC‘ has taken much of the limelight as he overruled “normal” participants by using the advanced features of the Nxt Blockchain as well as his stake to get ahead of the competition from Day 1.

In what was supposed to be a fair and equal early-bird lottery, divided into 12 batches as a way to stop whales from buying up all the tokens in the early stage of the ICO (as they tend to do), the IGNIS ICO was meant to be different.

 

The Get-There-First Hackathon

The theory that MAAC had used a bot to pick up the first 2 batches of Round 1 got turned down by MAAC himself, but behind the scenes, intense coding WAS going on, and an investment bot with the aim to out-compete all other attempts to invest in the IGNIS ICO WAS underway.

Only the bot was coded by Jelurida.

Those not following us on Twitter, FB, or having signed up for Nxt email newsletters, we hope you did not miss the release of NRS 1.11.7.

NRS 1.11.7 is not a small bugfix release – you must run this client version if you want a chance to get JLRDA tokens from the ICO. Furthermore, with NRS 1.11.7 you will not have to get up early / stay up late for the 2 daily 30-minute release windows, you can just enter your bid in advance and check the result of the lottery later as it fits your schedule. Read more… 

Also see: https://nxtforum.org/general-discussion/i-just-want-to-say-what-a-big-deal-1-11-7-is/

 

Lior Yaffe (Riker) has uploaded this tutorial:

So, are we equal now?

Well… Anyone can place bids on even terms. But….

A public message from another whale that got his hands on most of Batch #7, soon kicked off discussions among new and veteran Nxt users.

 

Speculation and over-thinking

Coincidence? Will leasing your NXT stake to a forging pool optimize your chances of getting an early stake in IGNIS? Could it be that connecting to 500 peers instead of the client’s default helps? How about hallmarking your node, will that give extra chances? How much does the size of the fee matter?

Well, let me be straight: About as much as the color of the shirt I wear matters.

Private discussion groups have been forming in Slack and all kind of mods and optimization tricks have been pulled off and tested, but no matter how hard anyone tries, the facts are hard to ignore:

bidji [9:20 AM]

basically luck

Scor2k, developer of NxtBridge and NxtBridge-OFFLINE:

I tweaked nxt.properties to connect to many more nodes than default, and also set it to broadcast transactions to like 50 nodes instead of default 20.

# Maximum number of outbound connections.
nxt.maxNumberOfOutboundConnections=100

# Maintain active connections with at least that many peers.
nxt.maxNumberOfConnectedPublicPeers=75

apenzl [1:02 PM]

Were you forging or was your account balance leased to a forging account?

scor2k [1:03 PM]

No )))

The number of Nxt nodes is growing, Nxtwiki sees new visitors; driven by a monetary incentive crypto investors are learning about the Nxt technology, not just the coin, which will be the backbone of Ignis and the Ardor Platform. And so, they begin to understand Nxt’s features (mind you, most crypto ICO’s usually sell tickets to not-existing technology – Nxt has been running stable and been improved upon by world-class developers for almost 4 years).

This is good.

By learning about the NRS client and server they grasp the power of Nxt, Ignis, and Ardor.

IGNIS logo

forkedchain [9:39 PM]

it appears that MAAC was splitting his NXT into orders with 400.000 NXT in each

napdude [9:43 PM]

MAAC risked tons of nxt to get his fills in the last many rows

 

“This shit project will not exist next year”!

Oh yes, it will. We must emphasize something, though:

Nxt’s powerful ‘Smart Transactions’ (inbuilt smart contracts) are only as smart as the people using them! Some people get desperate or make transactions too fast without knowing what they do.

Then they get angry.

PLEASE DO NOT PLAY AROUND WITH FEATURES YOU DON’T UNDERSTAND!

A few ICO adventurers have tried to take shortcuts but ended up worse than they started.

Some have bought JLRDA look-a-like currencies from the Monetary Exchange, fake JLRDA assets on the Nxt AE or the Nxt Marketplace, despite all warnings. One new user managed to broadcast a phased transaction to himself, which has locked his NXT for 7 days, using advanced functionality in the client.

One new user managed to broadcast a phased transaction to himself, which has locked his NXT for 7 days, using advanced functionality in the client.

That’s “learning the hard way”. One can react sanely, or by simply crying “shit ICO you bad take my money”, frown publicly upon Nxt, Ignis, Ardor, Jelurida – and about everything from the 1 NXT transaction fees to – understandably – not being able to get in at this very early point of the ICO.

Most though has found the ICO setup ingenious.

The adrenaline!!!!

Yes, IGNIS will be traded on exchanges eventually, and ICO participants may or may not (well, we won’t give trading advice here) make a fortune from their early investment, but what Jelurida is selling are operational tokens, the access to the first child chain of the Ardor Blockchain Platform.

Don’t fall for scammers

An old scam trick on the Nxt blockchain is sending out teasers in the form of tokens, for example, an asset issued for 1000 NXT but worth a lot more if the scammer succeeds, so he sends it to NXT accounts, it’s like ads on blockchain, an airdrop of assets which he hopes will make Nxt users think: Wow. Is this what I’m looking for? I’ll buy more!

No you won’t. Delete the assets or just let them be.

scor2k [10:34 AM]

May the forge be with you (c)


IGNIS ICO Report 2

Did you hold your breath?

Never mind, the second 5M batch of the IGNIS ICO got snatched by MAAC the Whale. And also most of the third.

But look at this now:

Live data from the Nxt blockchain

69 new buyers got their hands on JLRDA  –

no ninja tricks, no bots, just by using the full Nxt client. It’s a race to get in, sure. Back hurts from leaning forward towards the screen, eyes burn from staring without blinking, and personally, I burned my dinner in the oven because I didn’t dare to leave the computer within the ICO time frame. And I wasn’t even among the lucky 69. Transaction sent, the fee goes to forgers, try again if you want.

Only 5M of the ICO tokens are released in each batch in this Round 1, so maybe it’s better to wait. It’s just that… buying IGNIS for 0.4 NXT per token would be pretty nice, right.

What’s next?

Kristina (Jelurida) gives us this update in nxtchat.Slack:

Dear Nxt community members, thank you for your contribution in the first 2 days of the IGNIS ICO!

We are carefully considering the feedback and we are looking into possible ways to ensure that all the Nxters and also newcomers can participate in the IGNIS crowdsale more easily.

We also recommend to everybody to configure their Nxt client as a full node to avoid overloading the public nodes.

Jelurida has started moving funds to Bittrex, which is one of the higher volume NXT exchanges.

As people are beginning to calm down now, lots of thoughts and research by both new and veteran Nxters is ongoing, about the method MAAC uses and – not least perhaps – how to copycat it.

Another piece to this puzzle came from MAAC himself, as he uploaded a second public message to the Nxt blockchain:

Now guess who forged the block with the 4th JLRDA bid offer and 1009 NXT in fees while at work? Ahem, yeah

Questions?

So, does all this mean that Jelurida is incapable of running a fair ICO on the platform they designed themselves? Will this be Nxt’s “bad distribution” issue all over again? Is MAAC a heartless attacker, a movie theater worker with great belief in the work of Jelurida or just a greedy whale? Will he succeed or can Jelurida exploit his methods and succeed in creating equal terms for all?

In the coming days, we will dig into this in much greater detail, and not least explain about IGNIS, and all the advantages of the revolutionary new Ardor platform.

The JLRDA release schedule is as posted from Jelurida, remember each one is a batch of 5 M tokens:

Aug 5th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 6th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 7th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 8th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 9th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 10th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC

The coin sale will last for months so do not worry if you are not able to participate immediately, there will be many opportunities to participate in the IGNIS ICO.

In addition to the ongoing ICO, approximately half of the IGNIS coins in existence will be distributed automatically to NXT holders based on their account balances at the time of the Ardor Genesis Snapshot, at 1 NXT = 0.5 IGNIS ratio.

 

IGNIS ICO Report 1

The long awaited crowd sale of the IGNIS token has begun.

For sale are 440,000,000 Jelurida tokens (JLRDA) out of 1,000,000,000 total.

The Nxtchat.slack has been buzzing for weeks with anticipation and discussions of how to get your hands on these JLRDA tokens and this article contains some important information pertinent to your investing decisions.

1st round sold out in a flash

IGNIS logo

Boom – first round is over…

Eager participants from all around the globe were ready, eagerly staring at their desktop clients with the ICO window open in their NRS Client, excitedly building tension in Slack, ready to purchase.

And then…

The shock – as everyone realized that the first ICO round was over even before Jelurida’s exchange offer had hit the client GUI! The first 5M JLRDA tokens had been sucked up by a single whale in a flash.

1% of the JLRDA tokens available in the ICO had been sold without anyone even seeing the offer let alone having a chance to place their orders in the client!

What happened?

Take a look at the whale’s account.

https://nxtportal.org/accounts/11731960900805566730

Lots of phased transactions. Buy offers put into every block within the announced time frame of the first round, just waiting for his approval to be executed.

But how could he react so fast? One sound theory is that the buyer had a bot listening to the network and as soon as the exchange offer was put by Jelurida, still unconfirmed, he executed the transaction in that same block.

First reactions were harsh. From emotional accusations from disappointed users that the ICO round had to be an “inside job”, to conspiracy theories and sad claims that all IGNIS tokens most certainly would be sucked up by rich investors only, “just like in the fiat world”, hit the world wide web by storm.

And now, few hours before the next batch of 5M JLRDA tokens are to be released, we can only wait and prepare for our second chance to get in. No, “MAAC” did not play it fair in Round 1 but after all, he played it well AND played everybody by the rules of the tech. Rules that can be dug into by everybody, by the way.

Here’s a statement he made, sent from his phasing account:

Jelurida has released a schedule of the availability of the batches for the first round of JLRDA. 55 M tokens are left in 11 bins of 5 M, staggered by 12 hours to make it harder for whales (people with massive amounts of NXT) like MAAC to buy the entire amount.

The release schedule is as posted from Jelurida:

Aug 5th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 6th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 7th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 8th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 9th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC
Aug 10th between 06:45 – 07:15 UTC and between 18:45 – 19:15 UTC

In the coming hours and days, we will keep you posted about the progress of the ICO, as well as explain in much greater detail about IGNIS, Ardor, and all the advantages of this revolutionary new platform.

The coin sale will last for months so do not worry if you are not able to participate immediately, there will be many opportunities to participate.

Let’s see what happens. Meanwhile, the discussion is ongoing:
https://nxtforum.org/general-discussion/ignis-token-sale-progress/

In addition to the ongoing ICO, approximately half of the IGNIS coins in existence will be distributed automatically to NXT holders based on their account balances at the time of the Ardor Genesis Snapshot, at 1 NXT = 0.5 IGNIS ratio.

IGNIS ICO Report 2 >

Jelurida Announces New Details About the ICO

Earlier today, Jelurida, the development company behind Nxt and Ardor, has announced new details about the upcoming ICO on their website.

The Jelurida team is now happy to announce that the legal, technical and organizational preparations for the IGNIS ICO are entering their final stage. The ICO will start near the end of July or early August 2017 (exact date and time to be disclosed at least two weeks in advance).

After inquiries into the start date of the ICO have been asked by the community on a daily basis, this should hopefully bring some clarity now on how the rest of Q3 will shape up to be like, even if no exact date has been given yet.

 

NXT in the ICO

As mentioned in our earlier newsletter, Jelurida mentioned that NXT will be used in the ICO and that this was due to technical reasons. Now, with the announcement, we can see why this was chosen.

The token sale itself will be conducted on the Nxt blockchain platform. A “controllable currency” called JLRDA will be issued and offered for sale in several consecutive rounds.

Being a controllable currency, the JLRDA tokens will not be tradeable or transferable between user accounts. The purchased JLRDA currency units will only serve as a proof of ownership and initial IGNIS balance for the Ardor Genesis Snapshot.

Purchasing JLRDA tokens will require NXT, however users will be able to exchange other cryptocurrencies to NXT conveniently within the Nxt wallet using the integrated ShapeShift and Changelly third party exchanges, subject to availability.

For 1 JLRDA token the participants in the ICO will receive 1 IGNIS coin at the time of the Ardor Genesis Snapshot.

So, the IGNIS ICO will utilize the Monetary System feature of the Nxt blockchain, where a controllable currency called JLRDA will represent the IGNIS to be distributed when Ardor launches. Purchasing a controllable currency on Nxt directly requires NXT as the transactions are on the Nxt blockchain itself.

 

Ardor Genesis Snapshot

The announcement also shed some light on the snapshot date for NXT balances where 0.5 IGNIS is given for every NXT an account holds.

As already promised, approximately half of the IGNIS coins will be reserved and distributed automatically to the NXT holders based on their account balances at the time of the Ardor Genesis Snapshot, at 1 NXT = 0.5 IGNIS ratio.

The Ardor Genesis Snapshot will be performed at least two weeks after the end of the last JLRDA sale round.

However, since the exact date of the start of the ICO and the duration of the ICO are still unknown, we can only estimate when the Ardor Genesis snapshot will happen.

 

Important Notice

There have been some complaints on some channels in the community about false information being spread around, such as that the launch was supposed to happen on July 1st, despite multiple announcements for over a year that Q3 was when Ardor would launch, not necessarily July 1st. Because of this confusion, Jelurida was prompted to also state this in their announcement:

IMPORTANT NOTICE:
All official information regarding the IGNIS ICO will be published on this website only. If you receive information from other sources always make sure that it is consistent with this page.

While Nxter Magazine strives to provide the most accurate information, if any conflicting information is found on this website with Jelurida, please trust the content posted on Jelurida’s website as they are the development team and may have made some changes and we just did not get to update our content yet.

Source: https://www.jelurida.com/ico