# data[].attributes.attachment_link.readable_text
It's apples and oranges. Hashgraph is very similar but completely different to other non-blockchain DLTs.

Update 28/3/2018: This section has been updated to include feedback on specific sections from Paul Madsen, technical lead at Swirlds and key Hashgraph developer.

Distributed ledger technology (DLT) refers to the system that underpins cryptocurrencies. This is the decentralised ledger that records all transactions, forms consensus and keeps the network secure. Blockchain is used by bitcoin and many more, and is undoubtedly the best-known type of DLT.

Blockchain systems store transactions as a string, one after another. This chain is secured by being observed by "nodes," who essentially keep a close watch on the blockchain and make sure they're all looking at the same thing, and that no one's trying to do any funny stuff to the network. These nodes are usually miners.

This is very robust and highly secure, but inherently slow and only able to handle a certain amount of transactions at once. The original bitcoin blockchain, for example, tended to hit its limit at only 7 transactions per second while Ethereum capped out at around 15.

This inherent limitation is often called the "scaling problem," and solving it is often seen as one of the main obstacles for cryptocurrencies to overcome.

Cryptocurrencies have been exploring different ways around this. Some of the more popular approaches are:

On-chain solutions - Fit more transactions onto the existing chain. Bitcoin Cash did this by simply increasing bitcoin's block size from 1MB to 8MB. It's generally regarded as more of a bandaid than a permanent scaling solution though.

Sharding - Break up the blockchain into independent sections that can be processed by different nodes. Ethereum plans to implement this alongside layered solutions.

Layered solutions - Run some transactions off the main blockchain to ease the load on the main chain. The bitcoin Lightning Network is a layered solution.

Non-blockchain DLTs - Move away from blockchain technology entirely and look for brand new solutions. This is a tough nut to crack, but Hashgraph has joined the other cryptocurrencies making big strides in this area.

Post-blockchain systems

A handful of cryptocurrencies are moving away from blockchain systems, creating entirely new types of DLT in the process. The most common blockchain alternative is a directed acrylic graph (DAG) system.

In simple terms, this is basically just a blockweb rather than a blockchain. By breaking free of the rigid chain system, there's room for a lot more transactions and a potentially permanent solution to the scaling problem. These systems tend to entirely remove the concepts of blocks, block size and miners from the equation, and mostly aim for instant zero fee transactions.

All the most prominent DAG systems are highly complex and entirely unique.

Byteball Bytes - Blockless Design. The Byteball DAG removes blocks and instead connects individual transactions along a main chain that gravitates towards prominent users.

IOTA - The Tangle. This is a giant web of transactions, using a randomness-based system where every one transaction will verify two others.

Hashgraph is an entirely new DAG-style system, and it's attracting a lot of attention by claiming to achieve much better security and higher scalability than the others.

How does Hashgraph work?

Hashgraph uses a random gossip protocol. This essentially means each transaction in the network talks about itself to two randomly chosen nodes, which then pass it on to other nodes until enough nodes on the network can know exactly what's happening.

Consensus is reached when enough nodes are sufficiently informed to vote on the current state of the network and reach consensus. This entire process happens almost instantly.

How does Hashgraph compare to other DAGs?

By the numbers, Hashgraph might be one of the more impressive systems around. It's extremely fast, reportedly able to handle over 250,000 transactions per second, and has been mathematically proven to be highly secure and asynchronous byzantine fault tolerant.

Hashgraph is aBFT. This is a significant achievement that's eluded some other DAGs so far and is important because security has been a tough problem for DAGs to solve as their complex networks are also more fragile than blockchains in some ways. In this respect, Hashgraph might have some clear advantages over other DAG systems.

However, it had to make certain sacrifices in order to achieve this, says Yaoqi Jia, head of technology at Zilliqa.

It's important to note that Hashgraph is operated by a for-profit company called Swirlds, and it decides who gets to be a node. This naturally makes it much easier to make certain assumptions about network security. For example, it can safely assume that no hostile entity will generate multiple nodes in an attempt to influence the network and so doesn't need to bother securing against this. Mathematically defending against these so-called "Sybil" attacks is a major drain for public cryptocurrency networks, and not needing to worry about that might go a long way towards explaining Hashgraph's exceptional speed.
Madsen: Swirlds owns the patent for hashgraph and uses the corresponding license in two distinct ways 1) we sell hashgraph to enterprises to run in permissioned ledgers, eg a bunch of credit unions, or a supply chain etc. This is like lots of other enterprise software once we sell the license to an enterprise , we have zero ability to influence who they give the software to for running a node. 2) we grant to the Hedera council the sole & irrevocable license to build a public ledger based on hashgraph. Swirlds in involved in bootstrapping the Hedera ledger and as such have been involved in picking the initial members of the Hedera governing council. We also expect that it will be these 39 enterprises running the nodes in the early days . In this sense, Swirlds has some early influence in who will run the nodes on the public ledger
But if one entity does manage to get enough nodes approved by Swirlds, or if someone manages to take control of enough already-approved nodes, they might be able to hijack the entire network. Plus, Swirlds as a for-profit business has absolute control over the network which causes some major trust issues. This is probably a deal-breaker for any company that's after a very long term DLT solution.
Madsen: See above, for permissioned networks we have zero ability to control nodes. For the public Hedera network, we have some influence in early days (but no more than the other 39 governing members) and in the long run, will have zero influence because anybody can run nodes
And at this stage, its software is also closed source, which makes it difficult to verify some of its claims, and raises the likelihood of there being other vulnerabilities that Swirlds hasn't discovered. This arrangement also means it's going to be relatively centralised, with dozens or hundreds of different nodes rather than the potential millions or billions that public DAG networks like IOTA and Nano are aiming for.
Madsen: The node software will be open review, allowing anybody to download the code, and check for any such vulnerabilities. Consensus will absolutely NOT be centralized. We expect/want to have millions of nodes, with none of them having any undue influence.
In contrast to all of this, Byteball, Nano and IOTA are public, open source and largely decentralised systems. Although IOTA still has a central coordinator to give the network "training wheels" until it has enough nodes to achieve better throughput and security.
Madsen: I think you are conflating two things. We can talk about centralization in both the actual consensus, and almost completely orthogonally, in the governance and licensing model. IOTA is very centralized at the moment with, as you say, a coordinator (and a somewhat vague roadmap on getting rid of that coordinator). I submit you gave them too easy a pass here :-) DPOS systems like EOS & Cardano are somewhat centralized in consensus, with specialized delegates being given the right to produce blocks I will posit that hashgraph is the most decentralized in consensus of any system Separately, we can talk about the governance & licensing IOTA et al are open source, like BTC etc. And the market is incredibly fragmented because of the trivial ease with which anybody can launch a new coin or ledger. Some are arguing the value of fully decentralized governance through an on-chain model (like Tezos) where anybody with stake can have a vote in deciding how the ledger will evolve. Possibly interesting but lots of potential issues, ie Ive seen reports that voter participation is extremely low, eg less than 10%. Remains to be seen how viable this is The Hedera governance model is somewhat centralized, with 39 different known & credible enterprises given the right & responsibility to govern. We look at the current chaos & volatility of the public ledgers & coins, with constant & rampant forks & clones - and think its time for some maturity & expertise to be brought to governance
Overall, despite the technical similarities, Hashgraph is functionally extremely different from other DAG cryptocurrencies. By the numbers, it's extremely good, but it's also fragile and can only operate in a very sterile environment. Dropping Hashgraph into the same environment as Byteball, Nano or IOTA would be like dropping a goldfish into the ocean, with a similar impact on its life expectancy.
Madsen: an unfair characterization. hashgraph is very non-fragile & resilient. Ask IOTA how resilient they are to the coordinator being DDOSed. In a public ledger, we will use proof of stake to inhibit
"If and when used in a public setting, Hashgraph will face the same issues that other public blockchains are facing today and may not be able to maintain its security and performance," Jia concluded.
Madsen: of course, we know we have to prove ourselves.
These downsides won't be an issue for many applications, and companies who are happy to enter into a business relationship with Swirlds and purchase the use of Hashgraph as a service on which to create high speed DLT applications. For example, Intiva Health is using it to create a system to more efficiently manage the credentials of medical practitioners.

But other brands can't risk putting all their eggs in one basket by entrusting critical systems to a third party, especially for life and death products, and will need to use public DLTs instead, which aren't quite ready for prime time yet. For example, Volkswagen is a key partner of the IOTA project and aims to one day use the Tangle for control of autonomous vehicles.
Disclosure: At the time of writing the author holds ETH, IOTA, ICX, VEN, XLM, BTC, XRB Picture: Shutterstock

# data[].attributes.attachment_link.title
Hashgraph vs IOTA: Simple guide to non-blockchain cryptocurrencies | finder.com.au

# data[].attributes.attachment_link.description
Update 28/3/2018: This section has been updated to include feedback on specific sections from Paul Madsen, technical lead at Swirlds and key Hashgraph developer. Distributed ledger technology (DLT) refers to the system that underpins cryptocurrencies. This is the decentralised ledger that records all transactions, forms consensus and keeps the network secure.

# data[].attributes.attachment_link.readable_text
Look what I have found in the comment section of one video about hedera:

One of the users on the internet did some research on Google patents in 2020: I just searched "hashgraph" and went through the findings. It looks like hashgraph is on the radar of some pretty big companies. Note: A couple of the companies that have patents (pending), which referenced hashgraph are now on the council (Wipro, Deutsche Telekom). Anyways, none of this is to say that any of these big companies will become council members. It's just to say that large companies are aware of Hashgraph technology. This one was interesting. A published patent by JP Morgan for "System and method for distributed ledger-based software supply chain management" Hashgraph is mentioned 7 times.

JP Morgan https://patents.google.com/patent/WO2020018523A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=4

Barclays with a patent pending mentioning hashgraph https://patents.google.com/patent/US20200178069A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=5

Alibaba mentioning Hashgraph https://patents.google.com/patent/US10681083B2/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=5

Motorola https://patents.google.com/patent/WO2020086246A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=7

Wipro (which ending up becoming a council member) https://patents.google.com/patent/US20200211000A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=11

Samsung (with a machine learning patent referencing Hashgraoh or IOTA) https://patents.google.com/patent/WO2019209059A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=12

Ebay mentioning Hashgraph/Ethereum https://patents.google.com/patent/US20200177372A1/en?q=hashgraph+ebay&oq=hashgraph+ebay

Amazon mentioning digital certificates using various DLT protocols, including hashgraph https://patents.google.com/patent/US20200052911A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=3

Deutsche Telekom w/ a published patent w/ Hashgraph https://patents.google.com/patent/EP3528112A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=13

Sony talking about secure decentralized video game platform transactions using DAG technology (mentioning hashgraph once) https://patents.google.com/patent/US20190282906A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=13

Visa (digital fiat currency) mentioning Ethereum + hashgraph https://patents.google.com/patent/WO2020097533A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=14

Adobe https://patents.google.com/patent/US20200159847A1/en?q=%22hashgraph%22&oq=%22hashgraph%22&page=15

# data[].attributes.attachment_link.description
Look what I have found in the comment section of one video about hedera: One of the users on the internet did some research on Google patents in 2020: I just searched "hashgraph" and went through the findings. It looks like hashgraph is on the radar of some pretty big companies.

# data[].attributes.attachment_link.title
Blockchain is Eating Wall Street | Alex Tapscott | TEDxSanFrancisco

# data[].attributes.attachment_link.description
Author of best seller "blockchain revolution", Alex share in this talk about how the blockchain the technology behind bitcoin Is changing money, business, and the world. Alex Tapscott is the CEO and Founder of Northwest Passage Ventures, a consulting firm focused on early-stage, high growth companies in the Canadian and U.S.

# data[].attributes.attachment_link.title
The Best Documentary Ever - The Bitcoin Phenomenon

# data[].attributes.attachment_link.description
Produced for SQ1.tv, this Bitcoin looks at the history, the ideologies, and the conflict between the politics of the early-adopters and the . Produced for SQ1.tv, this Bitcoin looks at the history, the ideologies, and the conflict between the politics of the early-adopters and the . The Bitcoin .

# data[].attributes.headline
Audio: Bitcoin Overview and some finance history

# data[].attributes.subject
Audio: Bitcoin Overview and some finance history

# data[].attributes.attachment_link.title
Trace Mayer: Bitcoin Not in a Bubble Until it Hits $27k?

# data[].attributes.attachment_link.title
Everything You Need to Know About Bitcoin: VICE Podcast 027

# data[].attributes.attachment_link.description
This week on the VICE Podcast, Reihan Salam sits down with Jerry Brito, one of the leading experts on Bitcoin. Jerry is a senior research fellow at George Mason University's Mercatus Center and director of its Technology Policy Program. His research focuses on internet policy, copyright, and the regulatory process.

# data[].attributes.attachment_link.readable_text
While both mining via Proof of Work (POW) and staking are two of the most popular ways to perform work to earn income, cryptocurrencies are also susceptible to advances in computing, which could undercut the value of the coins by making them much easier and less expensive to mine. The dawn of quantum computers is upon us. And while this causes many to fear the loss of income potential, the truth is that an increase in difficulty to mine or stake is factored into the underlying algorithms in blockchain systems which have adjusted accordingly from central processing units to graphics processing units. From field-programmable gate array to application-specific integrated circuits.

The real threat quantum computing has for cryptocurrency work systems is in attacking the public-key cryptography.
Quantum Computing and Bitcoin
Satoshi Nakamoto created Bitcoin on the unspent transaction output (UTXO) model. In basic terms, think of all bitcoins in your wallet as change. When making a payment, this change is combined and sent. Once bitcoin is spent, the public keys of that address are broadcast to the entire network so that they can verify that you signed the coins over to a new address. Quantum computers have the ability to reverse your private key from your public key, so address reuse becomes a problem.

With the UTXO model, any change you have from a transaction will go to a newly generated address. All addresses which have never been spent are safe from a public-key attack because the key has not been broadcast. This does not change the fact that many basic users reuse addresses for convenience and many work protocols like POS reuse addresses as well.
Vulnerabilities in POS
To generate passive income by POS, this process is called staking. During staking, some of your coins are locked and unavailable to spend. Similar to a savings account in a bank, these coins are reserved by the network for a short period of time. In return for borrowing these coins the owner receives interest (coins) just like banks pay customers interest. POS coin supplies are inflationary at a variety of yearly rates; providing stakers better interest than local banks or credit unions.

In most cases, your coins need to be available to the network (online) in order to be staked. However, if you lack guaranteed internet connectivity or just prefer not to keep your wallet online all the time in order to mitigate potential exposure to security risks, you are at a disadvantage because you can't earn passive income on your coins while they are offline.

While staking is considerably less energy intensive, POW is still considered by many to be superior to POS. One of the chief arguments for that position is a security flaw in staking systems - POS gives away your public key when you stake.

This argument has merit because in most cases coins are stored in a small amount of addresses, mostly one, and that address is unlocked (unencrypted) for staking. The public key of these unlocked staking addresses is regularly being broadcast to the network.

One project building resistance to quantum computing is , the open-source privacy framework built on blockchain technology. Here's a look at how that project leverages innovations like cold staking, multi-signatures and HD wallets to improve POS security, maximize income-generation and provide secure, private, flexible spending options for owners of its token, PART.
Cold Staking
In its most basic terms, cold staking keeps your spend public key and private key private.

While you still need to be online to generate stakes, cold staking leverages multi-signature addresses so you can stake from multiple computers. A person earning passive income on a network with cold staking, like Particl's, can set up a dedicated stake-only machine while simultaneously spending those coins around the world on any mobile HD wallet like Ledger or Particl's own Copay App.

In terms of quantum resistance, this makes reversing private keys to public keys nearly impossible. For beginners, the stake-only machine is broadcasting a public key that is different than the mobile wallet key. In order to steal coins, both private keys would need to be known when using multi-signature. The more computers broadcasting stakes and spending stakes the greater the resistance becomes.

On November 10, the Particl network will have a planned hard fork to activate cold staking on the main blockchain. The team has been community testing this new feature on its test network since the beginning of August.
Summary
Although most cryptocurrencies lack cold staking support, Particl is not the only platform to support it. A few others, such as BlueCoin and BlackHalo, also enable cold staking.

If you're seeking to build a reliable passive income stream over the long-term using cryptocurrency, a feature like quantum resistance is important. If the past half-century is any indication, computers will always grow more and more powerful. A sudden advance in computing technology could practically wipe out the value of coins that lack quantum resistance.

As the cryptocurrency world evolves and grows more complex, generating income reliably using cryptocurrency is also becoming more challenging. Features like cold staking and quantum resistance provide income-generation benefits and guarantees that are now available from core cryptocurrency platforms like Particl.

# data[].attributes.attachment_link.title
Quantum Computing and Building Resistance into Proof of Stake - Bitcoin Magazine

# data[].attributes.attachment_link.description
While both mining via Proof of Work (POW) and staking are two of the most popular ways to perform work to earn income, cryptocurrencies are also susceptible to advances in computing, which could undercut the value of the coins by making them much easier and less expensive to mine.

# data[].attributes.attachment_link.title
Overstock.com: Hear the Patrick Byrne Story

# data[].attributes.attachment_link.description
Overstock's CEO Patrick Byrne talks about running one of the largest online retail websites in the world and how he got to be where he is today, as well as the future of Overstock.com and the possibility of leading a movement toward wider-spread adoption of Bitcoin.

# data[].attributes.headline
Video: Blockchain Technical Visual Explanation

# data[].attributes.subject
Video: Blockchain Technical Visual Explanation

# data[].attributes.body
Video and prompts

# data[].attributes.attachment_link.readable_text
Now that you've gotten the 10,000-foot overview of what a blockchain is, let's dive deeper into the main components that the Ethereum system is comprised of:
One note before getting started: whenever I say "hash" of X, I am referring to the hash, which Ethereum uses.
Accounts

The global "shared-state" of Ethereum is comprised of many small objects ("accounts") that are able to interact with one another through a message-passing framework. Each account has a a state associated with it and a 20-byte address. An address in Ethereum is a 160-bit identifier that is used to identify any account.

Externally owned accounts, which are controlled by private keys and have no code associated with them.

Contract accounts, which are controlled by their contract code and have code associated with them.

There are two types of accounts:

Externally owned accounts vs. contract accounts

It's important to understand a fundamental difference between externally owned accounts and contract accounts. An externally owned account can send messages to other externally owned accounts OR to other contract accounts by creating and signing a transaction using its private key. A message between two externally owned accounts is simply a value transfer. But a message from an externally owned account to a contract account activates the contract account's code, allowing it to perform various actions (e.g. transfer tokens, write to internal storage, mint new tokens, perform some calculation, create new contracts, etc.).
Therefore, any action that occurs on the Ethereum blockchain is always set in motion by transactions fired from externally controlled accounts.
Unlike externally owned accounts, contract accounts can't initiate new transactions on their own. Instead, contract accounts can only fire transactions in response to other transactions they have received (from an externally owned account or from another contract account). We'll learn more about contract-to-contract calls in the " Transactions and Messages " section.

Account state

nonce: If the account is an externally owned account, this number represents the number of transactions sent from the account's address. If the account is a contract account, the nonce is the number of contracts created by the account.

balance: The number of Wei owned by this address. There are ¹⁰¹⁸ Wei per Ether.

storageRoot: A hash of the root node of a Merkle Patricia tree (we'll explain Merkle trees later on). This tree encodes the hash of the storage contents of this account, and is empty by default.

codeHash: The hash of the EVM (Ethereum Virtual Machine - more on this later) code of this account. For contract accounts, this is the code that gets hashed and stored as the codeHash. For externally owned accounts, the codeHash field is the hash of the empty string.

The account state consists of four components, which are present regardless of the type of account:

World state

Okay, so we know that Ethereum's global state consists of a mapping between account addresses and the account states. This mapping is stored in a data structure known as a Merkle Patricia tree.

a large number of leaf nodes at the bottom of the tree that contain the underlying data

a set of intermediate nodes, where each node is the hash of its two child nodes

a single root node, also formed from the hash of its two child node, representing the top of the tree

A Merkle tree (or also referred as "Merkle trie") is a type of binary tree composed of a set of nodes with:

The data at the bottom of the tree is generated by splitting the data that we want to store into chunks, then splitting the chunks into buckets, and then taking the hash of each bucket and repeating the same process until the total number of hashes remaining becomes only one: the root hash.

This tree is required to have a key for every value stored inside it. Beginning from the root node of the tree, the key should tell you which child node to follow to get to the corresponding value, which is stored in the leaf nodes. In Ethereum's case, the key/value mapping for the state tree is between addresses and their associated accounts, including the balance, nonce, codeHash, and storageRoot for each account (where the storageRoot is itself a tree).

This same trie structure is used also to store transactions and receipts. More specifically, every block has a "header" which stores the hash of the root node of three different Merkle trie structures, including:

The ability to store all this information efficiently in Merkle tries is incredibly useful in Ethereum for what we call "light clients" or "light nodes." Remember that a blockchain is maintained by a bunch of nodes. Broadly speaking, there are two types of nodes: full nodes and light nodes.

A full archive node synchronizes the blockchain by downloading the full chain, from the genesis block to the current head block, executing all of the transactions contained within. Typically, miners store the full archive node, because they are required to do so for the mining process. It is also possible to download a full node without executing every transaction. Regardless, any full node contains the entire chain.

But unless a node needs to execute every transaction or easily query historical data, there's really no need to store the entire chain. This is where the concept of a light node comes in. Instead of downloading and storing the full chain and executing all of the transactions, light nodes download only the chain of headers, from the genesis block to the current head, without executing any transactions or retrieving any associated state. Because light nodes have access to block headers, which contain hashes of three tries, they can still easily generate and receive verifiable answers about transactions, events, balances, etc.

The reason this works is because hashes in the Merkle tree propagate upward - if a malicious user attempts to swap a fake transaction into the bottom of a Merkle tree, this change will cause a change in the hash of the node above, which will change the hash of the node above that, and so on, until it eventually changes the root of the tree.

1. A chunk of data to be verified and its hash

2. The root hash of the tree

3. The "branch" (all of the partner hashes going up along the path from the chunk to the root)

Any node that wants to verify a piece of data can use something called a "Merkle proof" to do so. A Merkle proof consists of:
In summary, the benefit of using a Merkle Patricia tree is that the root node of this structure is cryptographically dependent on the data stored in the tree, and so the hash of the root node can be used as a secure identity for this data. Since the block header includes the root hash of the state, transactions, and receipts trees, any node can validate a small part of state of Ethereum without needing to store the entire state, which can be potentially unbounded in size.
Anyone reading the proof can verify that the hashing for that branch is consistent all the way up the tree, and therefore that the given chunk is actually at that position in the tree.

Gas and payment

One very important concept in Ethereum is the concept of fees. Every computation that occurs as a result of a transaction on the Ethereum network incurs a fee - there's no free lunch! This fee is paid in a denomination called "gas."

Gas is the unit used to measure the fees required for a particular computation. Gas price is the amount of Ether you are willing to spend on every unit of gas, and is measured in "gwei." "Wei" is the smallest unit of Ether, where 1⁰¹⁸ Wei represents 1 Ether. One gwei is 1,000,000,000 Wei.

With every transaction, a sender sets a gas limit and gas price. The product of gas price and gas limit represents the maximum amount of Wei that the sender is willing to pay for executing a transaction.

For example, let's say the sender sets the gas limit to 50,000 and a gas price to 20 gwei. This implies that the sender is willing to spend at most 50,000 x 20 gwei = 1,000,000,000,000,000 Wei = 0.001 Ether to execute that transaction.

Remember that the gas limit represents the maximum gas the sender is willing to spend money on. If they have enough Ether in their account balance to cover this maximum, they're good to go. The sender is refunded for any unused gas at the end of the transaction, exchanged at the original rate.

In the case that the sender does not provide the necessary gas to execute the transaction, the transaction runs "out of gas" and is considered invalid. In this case, the transaction processing aborts and any state changes that occurred are reversed, such that we end up back at the state of Ethereum prior to the transaction. Additionally, a record of the transaction failing gets recorded, showing what transaction was attempted and where it failed. And since the machine already expended effort to run the calculations before running out of gas, logically, none of the gas is refunded to the sender.

Where exactly does this gas money go? All the money spent on gas by the sender is sent to the "beneficiary" address, which is typically the miner's address. Since miners are expending the effort to run computations and validate transactions, miners receive the gas fee as a reward.

Typically, the higher the gas price the sender is willing to pay, the greater the value the miner derives from the transaction. Thus, the more likely miners will be to select it. In this way, miners are free to choose which transactions they want to validate or ignore. In order to guide senders on what gas price to set, miners have the option of advertising the minimum gas price for which they will execute transactions.

There are fees for storage, too

Not only is gas used to pay for computation steps, it is also used to pay for storage usage. The total fee for storage is proportional to the smallest multiple of 32 bytes used.

Fees for storage have some nuanced aspects. For example, since increased storage increases the size of the Ethereum state database on all nodes, there's an incentive to keep the amount of data stored small. For this reason, if a transaction has a step that clears an entry in the storage, the fee for executing that operation of is waived, AND a refund is given for freeing up storage space.

What's the purpose of fees?

One important aspect of the way the Ethereum works is that every single operation executed by the network is simultaneously effected by every full node. However, computational steps on the Ethereum Virtual Machine are very expensive. Therefore, Ethereum smart contracts are best used for simple tasks, like running simple business logic or verifying signatures and other cryptographic objects, rather than more complex uses, like file storage, email, or machine learning, which can put a strain on the network. Imposing fees prevents users from overtaxing the network.

Ethereum is a Turing complete language. (In short, a Turing machine is a machine that can simulate any computer algorithm (for those not familiar with Turing machines, check out this and this). This allows for loops and makes Ethereum susceptible to the halting problem, a problem in which you cannot determine whether or not a program will run infinitely. If there were no fees, a malicious actor could easily try to disrupt the network by executing an infinite loop within a transaction, without any repercussions. Thus, fees protect the network from deliberate attacks.

You might be thinking, "why do we also have to pay for storage?" Well, just like computation, storage on the Ethereum network is a cost that the entire network has to take the burden of.

Transaction and messages
In the most basic sense, a transaction is a cryptographically signed piece of instruction that is generated by an externally owned account, serialized, and then submitted to the blockchain.
We noted earlier that Ethereum is a transaction-based state machine. In other words, transactions occurring between different accounts are what move the global state of Ethereum from one state to the next.

nonce: a count of the number of transactions sent by the sender.

gasPrice: the number of Wei that the sender is willing to pay per unit of gas required to execute the transaction.

gasLimit: the maximum amount of gas that the sender is willing to pay for executing this transaction. This amount is set and paid upfront, before any computation is done.

to: the address of the recipient. In a contract-creating transaction, the contract account address does not yet exist, and so an empty value is used.

value: the amount of Wei to be transferred from the sender to the recipient. In a contract-creating transaction, this value serves as the starting balance within the newly created contract account.

v, r, s: used to generate the signature that identifies the sender of the transaction.

init (only exists for contract-creating transactions): An EVM code fragment that is used to initialize the new contract account. init is run only once, and then is discarded. When init is first run, it returns the body of the account code, which is the piece of code that is permanently associated with the contract account.

data (optional field that only exists for message calls): the input data (i.e. parameters) of the message call. For example, if a smart contract serves as a domain registration service, a call to that contract might expect input fields such as the domain and IP address.

There are two types of transactions: message calls and contract creations (i.e. transactions that create new Ethereum contracts).

All transactions contain the following components, regardless of their type:

We learned in the " Accounts " section that transactions - both message calls and contract-creating transactions - are always initiated by externally owned accounts and submitted to the blockchain. Another way to think about it is that transactions are what bridge the external world to the internal state of Ethereum.
When one contract sends an internal transaction to another contract, the associated code that exists on the recipient contract account is executed.
But this doesn't mean that contracts can't talk to other contracts. Contracts that exist within the global scope of Ethereum's state can talk to other contracts within that same scope. The way they do this is via "messages" or "internal transactions" to other contracts. We can think of messages or internal transactions as being similar to transactions, with the major difference that they are NOT generated by externally owned accounts. Instead, they are generated by contracts. They are virtual objects that, unlike transactions, are not serialized and only exist in the Ethereum execution environment.

One important thing to note is that internal transactions or messages don't contain a gasLimit. This is because the gas limit is determined by the external creator of the original transaction (i.e. some externally owned account). The gas limit that the externally owned account sets must be high enough to carry out the transaction, including any sub-executions that occur as a result of that transaction, such as contract-to-contract messages. If, in the chain of transactions and messages, a particular message execution runs out of gas, then that message's execution will revert, along with any subsequent messages triggered by the execution. However, the parent execution does not need to revert.

Blocks

All transactions are grouped together into "blocks." A blockchain contains a series of such blocks that are chained together.

In Ethereum, a block consists of:

Ommers explained

What the heck is an "ommer?" An ommer is a block whose parent is equal to the current block's parent's parent. Let's take a quick dive into what ommers are used for and why a block contains the block headers for ommers.

Because of the way Ethereum is built, block times are much lower (~15 seconds) than those of other blockchains, like Bitcoin (~10 minutes). This enables faster transaction processing. However, one of the downsides of shorter block times is that more competing block solutions are found by miners. These competing blocks are also referred to as "orphaned blocks" (i.e. mined blocks do not make it into the main chain).

The purpose of ommers is to help reward miners for including these orphaned blocks. The ommers that miners include must be "valid," meaning within the sixth generation or smaller of the present block. After six children, stale orphaned blocks can no longer be referenced (because including older transactions would complicate things a bit).

Ommer blocks receive a smaller reward than a full block. Nonetheless, there's still some incentive for miners to include these orphaned blocks and reap a reward.

Block header

parentHash: a hash of the parent block's header (this is what makes the block set a "chain")

ommersHash: a hash of the current block's list of ommers

beneficiary: the account address that receives the fees for mining this block

stateRoot: the hash of the root node of the state trie (recall how we learned that the state trie is stored in the header and makes it easy for light clients to verify anything about the state)

transactionsRoot: the hash of the root node of the trie that contains all transactions listed in this block

receiptsRoot: the hash of the root node of the trie that contains the receipts of all transactions listed in this block

logsBloom: a Bloom filter (data structure) that consists of log information

difficulty: the difficulty level of this block

number: the count of current block (the genesis block has a block number of zero; the block number increases by 1 for each each subsequent block)

gasLimit: the current gas limit per block

gasUsed: the sum of the total gas used by transactions in this block

timestamp: the unix timestamp of this block's inception

extraData: extra data related to this block

mixHash: a hash that, when combined with the nonce, proves that this block has carried out enough computation

nonce: a hash that, when combined with the mixHash, proves that this block has carried out enough computation

Let's get back to blocks for a moment. We mentioned previously that every block has a block "header," but what exactly is this?

A block header is a portion of the block consisting of:

Notice how every block header contains three trie structures for:

These trie structures are nothing but the Merkle Patricia tries we discussed earlier.

Additionally, there are a few terms from the above description that are worth clarifying. Let's take a look.

Logs

Ethereum allows for logs to make it possible to track various transactions and messages. A contract can explicitly generate a log by defining "events" that it wants to log.

the logger's account address,

a series of topics that represent various events carried out by this transaction, and

any data associated with these events.

A log entry contains:

Logs are stored in a bloom filter, which stores the endless log data in an efficient manner.

Transaction receipt

the block number

block hash

transaction hash

gas used by the current transaction

cumulative gas used in the current block after the current transaction has executed

logs created when executing the current transaction

..and so on

Logs stored in the header come from the log information contained in the transaction receipt. Just as you receive a receipt when you buy something at a store, Ethereum generates a receipt for every transaction. Like you'd expect, each receipt contains certain information about the transaction. This receipt includes items like:

Block difficulty

The "difficulty" of a block is used to enforce consistency in the time it takes to validate blocks. The genesis block has a difficulty of 131,072, and a special formula is used to calculate the difficulty of every block thereafter. If a certain block is validated more quickly than the previous block, the Ethereum protocol increases that block's difficulty.

The difficulty of the block affects the nonce, which is a hash that must be calculated when mining a block, using the proof-of-work algorithm.

The relationship between the block's difficulty and nonce is mathematically formalized as:

The only way to find a nonce that meets a difficulty threshold is to use the proof-of-work algorithm to enumerate all of the possibilities. The expected time to find a solution is proportional to the difficulty - the higher the difficulty, the harder it becomes to find the nonce, and so the harder it is to validate the block, which in turn increases the time it takes to validate a new block. So, by adjusting the difficulty of a block, the protocol can adjust how long it takes to validate a block.

If, on the other hand, validation time is getting slower, the protocol decreases the difficulty. In this way, the validation time self-adjusts to maintain a constant rate - on average, one block every 15 seconds.

Transaction Execution

We've come to one of the most complex parts of the Ethereum protocol: the execution of a transaction. Say you send a transaction off into the Ethereum network to be processed. What happens to transition the state of Ethereum to include your transaction?

The transaction must be a properly formatted RLP. "RLP" stands for "Recursive Length Prefix" and is a data format used to encode nested arrays of binary data. RLP is the format Ethereum uses to serialize objects.

Valid transaction signature.

Valid transaction nonce. Recall that the nonce of an account is the count of transactions sent from that account. To be valid, a transaction nonce must be equal to the sender account's nonce.

The transaction's gas limit must be equal to or greater than the intrinsic gas used by the transaction. The intrinsic gas includes:

1. a predefined cost of 21,000 gas for executing the transaction

2. a gas fee for data sent with the transaction (4 gas for every byte of data or code that equals zero, and 68 gas for every non-zero byte of data or code)

3. if the transaction is a contract-creating transaction, an additional 32,000 gas

The sender's account balance must have enough Ether to cover the "upfront" gas costs that the sender must pay. The calculation for the upfront gas cost is simple: First, the transaction's gas limit is multiplied by the transaction's gas price to determine the maximum gas cost. Then, this maximum cost is added to the total value being transferred from the sender to the recipient.

First, all transactions must meet an initial set of requirements in order to be executed. These include:

If the transaction meets all of the above requirements for validity, then we move onto the next step.

First, we deduct the upfront cost of execution from the sender's balance, and increase the nonce of the sender's account by 1 to account for the current transaction. At this point, we can calculate the gas remaining as the total gas limit for the transaction minus the intrinsic gas used.

Next, the transaction starts executing. Throughout the execution of a transaction, Ethereum keeps track of the "substate." This substate is a way to record information accrued during the transaction that will be needed immediately after the transaction completes. Specifically, it contains:

the Ether for the gas is given to the miner

the gas used by the transaction is added to the block gas counter (which keeps track of the total gas used by all transactions in the block, and is useful when validating a block)

all accounts in the self-destruct set (if any) are deleted

Next, the various computations required by the transaction are processed.

Once all the steps required by the transaction have been processed, and assuming there is no invalid state, the state is finalized by determining the amount of unused gas to be refunded to the sender. In addition to the unused gas, the sender is also refunded some allowance from the "refund balance" that we described above.

Once the sender is refunded:

Finally, we're left with the new state and a set of the logs created by the transaction.

Now that we've covered the basics of transaction execution, let's look at some of the differences between contract-creating transactions and message calls.

Setting the nonce to zero

If the sender sent some amount of Ether as value with the transaction, setting the account balance to that value

Deducting the value added to this new account's balance from the sender's balance

Setting the storage as empty

Setting the contract's codeHash as the hash of an empty string

Contract creation

Recall that in Ethereum, there are two types of accounts: contract accounts and externally owned accounts. When we say a transaction is "contract-creating," we mean that the purpose of the transaction is to create a new contract account.

In order to create a new contract account, we first declare the address of the new account using a special formula. Then we initialize the new account by:

Once we initialize the account, we can actually create the account, using the init code sent with the transaction (see the "Transaction and messages" section for a refresher on the init code). What happens during the execution of this init code is varied. Depending on the constructor of the contract, it might update the account's storage, create other contract accounts, make other message calls, etc.

As the code to initialize a contract is executed, it uses gas. The transaction is not allowed to use up more gas than the remaining gas. If it does, the execution will hit an out-of-gas (OOG) exception and exit. If the transaction exits due to an out-of-gas exception, then the state is reverted to the point immediately prior to transaction. The sender is not refunded the gas that was spent before running out.

Boo hoo.

However, if the sender sent any Ether value with the transaction, the Ether value will be refunded even if the contract creation fails. Phew!

If the initialization code executes successfully, a final contract-creation cost is paid. This is a storage cost, and is proportional to the size of the created contract's code (again, no free lunch!) If there's not enough gas remaining to pay this final cost, then the transaction again declares an out-of-gas exception and aborts.

If all goes well and we make it this far without exceptions, then any remaining unused gas is refunded to the original sender of the transaction, and the altered state is now allowed to persist!

Hooray!

Message calls

The execution of a message call is similar to that of a contract creation, with a few differences.

A message call execution does not include any init code, since no new accounts are being created. However, it can contain input data, if this data was provided by the transaction sender. Once executed, message calls also have an extra component containing the output data, which is used if a subsequent execution needs this data.

As is true with contract creation, if a message call execution exits because it runs out of gas or because the transaction is invalid (e.g. stack overflow, invalid jump destination, or invalid instruction), none of the gas used is refunded to the original caller. Instead, all of the remaining unused gas is consumed, and the state is reset to the point immediately prior to balance transfer.
The part of the protocol that actually handles processing the transactions is Ethereum's own virtual machine, known as the Ethereum Virtual Machine (EVM).
Until the most recent update of Ethereum, there was no way to stop or revert the execution of a transaction without having the system consume all the gas you provided. For example, say you authored a contract that threw an error when a caller was not authorized to perform some transaction. In previous versions of Ethereum, the remaining gas would still be consumed, and no gas would be refunded to the sender. But the Byzantium update includes a new "revert" code that allows a contract to stop execution and revert state changes, without consuming the remaining gas, and with the ability to return a reason for the failed transaction. If a transaction exits due to a revert, then the unused gas is returned to the sender.

Execution model

So far, we've learned about the series of steps that have to happen for a transaction to execute from start to finish. Now, we'll look at how the transaction actually executes within the VM.

The EVM is a Turing complete virtual machine, as defined earlier. The only limitation the EVM has that a typical Turing complete machine does not is that the EVM is intrinsically bound by gas. Thus, the total amount of computation that can be done is intrinsically limited by the amount of gas provided.

Moreover, the EVM has a stack-based architecture. A stack machine is a computer that uses a last-in, first-out stack to hold temporary values.

The size of each stack item in the EVM is 256-bit, and the stack has a maximum size of 1024.

The EVM has memory, where items are stored as word-addressed byte arrays. Memory is volatile, meaning it is not permanent.

The EVM also has storage. Unlike memory, storage is non-volatile and is maintained as part of the system state. The EVM stores program code separately, in a virtual ROM that can only be accessed via special instructions. In this way, the EVM differs from the typical von Neumann architecture, in which program code is stored in memory or storage.

System state

Remaining gas for computation

Address of the account that owns the code that is executing

Address of the sender of the transaction that originated this execution

Address of the account that caused the code to execute (could be different from the original sender)

Gas price of the transaction that originated this execution

Input data for this execution

Value (in Wei) passed to this account as part of the current execution

Machine code to be executed

Block header of the current block

Depth of the present message call or contract creation stack

The EVM also has its own language: "EVM bytecode." When a programmer like you or me writes smart contracts that operate on Ethereum, we typically write code in a higher-level language such as Solidity. We can then compile that down to EVM bytecode that the EVM can understand.

Okay, now on to execution.

Before executing a particular computation, the processor makes sure that the following information is available and valid:

gas available

program counter

memory contents

active number of words in memory

stack contents.

At the start of execution, memory and stack are empty and the program counter is zero.

PC: 0 STACK: [] MEM: [], STORAGE: {}

The EVM then executes the transaction recursively, computing the system state and the machine state for each loop. The system state is simply Ethereum's global state. The machine state is comprised of:

1. The machine reaches an exceptional state (e.g. insufficient gas, invalid instructions, insufficient stack items, stack items would overflow above 1024, invalid JUMP/JUMPI destination, etc.) and so must be halted, with any changes discarded

2. The sequence continues to process into the next loop

3. The machine reaches a controlled halt (the end of the execution process)

Stack items are added or removed from the leftmost portion of the series.

On each cycle, the appropriate gas amount is reduced from the remaining gas, and the program counter increments.

At the end of each loop, there are three possibilities:

Assuming the execution doesn't hit an exceptional state and reaches a "controlled" or normal halt, the machine generates the resultant state, the remaining gas after this execution, the accrued substate, and the resultant output.

Phew. We got through one of the most complex parts of Ethereum. Even if you didn't fully comprehend this part, that's okay. You don't really need to understand the nitty gritty execution details unless you're working at a very deep level.

How a block gets finalized

Finally, let's look at how a block of many transactions gets finalized.

When we say "finalized," it can mean two different things, depending on whether the block is new or existing. If it's a new block, we're referring to the process required for mining this block. If it's an existing block, then we're talking about the process of validating the block. In either case, there are four requirements for a block to be "finalized":

1) Validate (or, if mining, determine) ommers
Each ommer block within the block header must be a valid header and be within the sixth generation of the present block.

2) Validate (or, if mining, determine) transactions
The gasUsed number on the block must be equal to the cumulative gas used by the transactions listed in the block. (Recall that when executing a transaction, we keep track of the block gas counter, which keeps track of the total gas used by all transactions in the block).

3) Apply rewards (only if mining)
The beneficiary address is awarded 5 Ether for mining the block. (Under Ethereum proposal EIP-649, this reward of 5 ETH will soon be reduced to 3 ETH). Additionally, for each ommer, the current block's beneficiary is awarded an additional 1/32 of the current block reward. Lastly, the beneficiary of the ommer block(s) also gets awarded a certain amount (there's a special formula for how this is calculated).

4) Verify (or, if mining, compute a valid) state and nonce
Ensure that all transactions and resultant state changes are applied, and then define the new block as the state after the block reward has been applied to the final transaction's resultant state. Verification occurs by checking this final state against the state trie stored in the header.

Mining proof of work

The " Blocks " section briefly addressed the concept of block difficulty. The algorithm that gives meaning to block difficulty is called Proof of Work (PoW).

mixHash isa hash that, when combined with the nonce, proves that this block has carried out enough computation

nonce is a hash that, when combined with the mixHash, proves that this block has carried out enough computation

Ethereum's proof-of-work algorithm is called " Ethash " (previously known as Dagger-Hashimoto).

The algorithm is formally defined as:

In the " Blocks" section, we talked about the various items that exist in a block header. Two of those components were called the mixHash and the nonce. As you may recall:

The PoW function is used to evaluate these two items.

How exactly the mixHash and nonce are calculated using the PoW function is somewhat complex, and something we can delve deeper into in a separate post. But at a high level, it works like this:

A "seed" is calculated for each block. This seed is different for every "epoch," where each epoch is 30,000 blocks long. For the first epoch, the seed is the hash of a series of 32 bytes of zeros. For every subsequent epoch, it is the hash of the previous seed hash. Using this seed, a node can calculate a pseudo-random "cache."

This cache is incredibly useful because it enables the concept of "light nodes," which we discussed previously in this post. The purpose of light nodes is to afford certain nodes the ability to efficiently verify a transaction without the burden of storing the entire blockchain dataset. A light node can verify the validity of a transaction based solely on this cache, because the cache can regenerate the specific block it needs to verify.

Using the cache, a node can generate the DAG "dataset," where each item in the dataset depends on a small number of pseudo-randomly-selected items from the cache. In order to be a miner, you must generate this full dataset; all full clients and miners store this dataset, and the dataset grows linearly with time.

Miners can then take random slices of the dataset and put them through a mathematical function to hash them together into a " mixHash." A miner will repeatedly generate a mixHash until the output is below the desired target nonce. When the output meets this requirement, this nonce is considered valid and the block can be added to the chain.

Mining as a security mechanism
Overall, the purpose of the PoW is to prove, in a cryptographically secure way, that a particular amount of computation has been expended to generate some output (i.e. the nonce). This is because there is no better way to find a nonce that is below the required threshold other than to enumerate all the possibilities. The outputs of repeatedly applying the hash function have a uniform distribution, and so we can be assured that, on average, the time needed to find such a nonce depends on the difficulty threshold. The higher the difficulty, the longer it takes to solve for the nonce. In this way, the PoW algorithm gives meaning to the concept of difficulty, which is used to enforce blockchain security.

What do we mean by blockchain security? It's simple: we want to create a blockchain that EVERYONE trusts. As we discussed previously in this post, if more than one chain existed, users would lose trust, because they would be unable to reasonably determine which chain was the "valid" chain. In order for a group of users to accept the underlying state that is stored on a blockchain, we need a single canonical blockchain that a group of people believes in.

a static block reward of 5 ether for the "winning'" block (soon to be changed to 3 ether)

the cost of gas expended within the block by the transactions included in the block

an extra reward for including ommers as part of the block

This is exactly what the PoW algorithm does: it ensures that a particular blockchain will remain canonical into the future, making it incredibly difficult for an attacker to create new blocks that overwrite a certain part of history (e.g. by erasing transactions or creating fake transactions) or maintain a fork. To have their block validated first, an attacker would need to consistently solve for the nonce faster than anyone else in the network, such that the network believes their chain is the heaviest chain (based on the principles of the GHOST protocol we mentioned earlier). This would be impossible unless the attacker had more than half of the network mining power, a scenario known as the majority 51% attack.

Make it accessible to as many people as possible. In other words, people shouldn't need specialized or uncommon hardware to run the algorithm. The purpose of this is to make the wealth distribution model as open as possible so that anyone can provide any amount of compute power in return for Ether.

Reduce the possibility for any single node (or small set) to make a disproportionate amount of profit. Any node that can make a disproportionate amount of profit means that the node has a large influence on determining the canonical blockchain. This is troublesome because it reduces network security.

Mining as a wealth distribution mechanism

Beyond providing a secure blockchain, PoW is also a way to distribute wealth to those who expend their computation for providing this security. Recall that a miner receives a reward for mining a block, including:

In order to ensure that the use of the PoW consensus mechanism for security and wealth distribution is sustainable in the long run, Ethereum strives to instill these two properties:

In the Bitcoin blockchain network, one problem that arises in relation to the above two properties is that the PoW algorithm is a SHA256 hash function. The weakness with this type of function is that it can be solved much more efficiently using specialized hardware, also known as ASICs.

In order to mitigate this issue, Ethereum has chosen to make its PoW algorithm ( Ethhash) sequentially memory-hard. This means that the algorithm is engineered so that calculating the nonce requires a lot of memory AND bandwidth. The large memory requirements make it hard for a computer to use its memory in parallel to discover multiple nonces simultaneously, and the high bandwidth requirements make it difficult for even a super-fast computer to discover multiple nonce simultaneously. This reduces the risk of centralization and creates a more level playing field for the nodes that are doing the verification.

One thing to note is that Ethereum is transitioning from a PoW consensus mechanism to something called "proof-of-stake". This is a beastly topic of its own that we can hopefully explore in a future post. ☺️

Conclusion

...Phew! You made it to the end. I hope?

There's a lot to digest in this post, I know. If it takes you multiple reads to fully understand what's going on, that's totally fine. I personally read the Ethereum yellow paper, white paper, and various parts of the code base many times before grokking what was going on.

Nonetheless, I hope you found this overview helpful. If you find any errors or mistakes, I'd love for you to write a private note or post it directly in the comments. I look at all of 'em, I promise ;)

And remember, I'm human (yep, it's true) and I make mistakes. I took the time to write this post for the benefit of the community, for free. So please be constructive in your feedback, without unnecessary bashing. ☺️

# data[].attributes.attachment_link.title
How does Ethereum work, anyway? - Preethi Kasireddy - Medium

# data[].attributes.attachment_link.description
Now that you've gotten the 10,000-foot overview of what a blockchain is, let's dive deeper into the main components that the Ethereum system is comprised of: One note before getting started: whenever I say "hash" of X, I am referring to the hash, which Ethereum uses.

# data[].attributes.attachment_link.readable_text
Bitcoin cryptocurrency blockchain is usually considered as the original blockchain of version 1.0, since this is the first modern implementation of the distributed ledger technology (DLT). Over time, blockchain 1.0 has evolved into Ethereum, which is considered to be the blockchain version 2.0. And now we are probably observing the birth of blockchain 3.0 in the form of Tangle or Hashgraph.

But such a division of blockchain development into three stages is a simplification, since blockchain 3.0 does not have a "block chain". Instead, the third generation DLT uses an oriented acyclic graph (DAG). From the article you will learn why DAG is called post-blockchain concept and how Tangle and Hedera Hashgraph differ from traditional blockchains.

The apparent weakness of the current blockchains

Judging by the headlines in the press, the blockchains of the first and second generation have already turned the world upside down. It seems that there is not a single sphere wherever the new technology has penetrated. However, in practice, the situation is somewhat different.

Blockchains such as Bitcoin and Ethereum have an important limitation that slows their implementation in the real sector. Speech on the problem of scalability: a critical reduction in throughput and transaction speed with a significant increase in transaction volumes. So, Bitcoin blockchain can process up to 7 operations per second (TPS), Ethereum - 20 TPS. PayPal or Visa has a much higher throughput: 200 and 56,000 TPS accordingly.

The problem of scalability arose from the fact that the developers of these blockchains had to solve the so-called blockchain trilemma, when of the three qualities - decentralization, security, and scalability - we must give preference to two.

The creators of Bitcoin and Ethereum chose security and decentralization, so their systems are not scalable. The developers of private blockchains (Hyperledger, R3 Corda, Quorum) refused to decentralize in favor of speed. In order not to compromise and get all three qualities of the trilemma, you need to reinvent the way to build a decentralized network.

Solving the scalability problem

Do you want to build a project? Contact us and we'll help you.

The developers and supporters of Bitcoin and Ethereum are aware of the weakness of their ecosystems and are trying to eliminate it through various updates. As for Bitcoin, here the main challengers for solving the problem of scalability are the technologies of Lightning Network and RootStock. In the case of Ethereum, at the top of the list are Sharding, Plasma and Caspar technologies.

Lightning Network or Sharding is a kind of add-on over the main blockchain network based on the following idea: not all network participants need to know all the information about transaction history in order to maintain effective network synchronization. This idea is the basis of the directed acyclic graph (DAG) approach.

The blockchain is based on a "vertical architecture", while the DAG operates on a "horizontal" scheme. In a blockchain network, transactions are grouped into new blocks, which are then added to the blockchain chain. In a "horizontal" DAG network, transactions are directly linked to other transactions, grouping them into blocks.

How DAG works

Directed. When a payment is made on the DAG network, it creates a connection with two (or more) last payments made on the network before it checks the balance and authenticity of older payments, and if everything is fine, the new payment confirms them.

Since new payments always check old ones, it is believed that the older the payment, the more "legitimate" it is and the harder to be cancelled. This is what is meant by the word "Directed" in the abbreviation DAG.

Acyclic. Literally means "not in a cycle." In the case of networks where new payments confirm old ones, this means that an old, already verified payment never checks a new one. That is, verification always goes ahead and never creates a similarity of at least some cycle.

Graph. The name of the payment and connection schedule. In the graph below: parallel lines are the history of records of nodes (users), circles are events (transactions), lines between events are connections from new events to old ones.

Since the DAG structure is similar to the web of verification, it is often called a tangle. And although this is not a blockchain, Tangle has the same properties as a decentralized blockchain: a distribution registry based on a peer-to-peer network. Consequently, Tangle, like the blockchain, is a mechanism for validating distributed decision making.

Tangle Network Principles

Tangle (IOTA cryptocurrency) is created by linking individual transactions into a single peer-to-peer network. Relationships between transactions are formed on the basis of a simple rule: for a new transaction to be confirmed, it must confirm two older transactions, each of which confirmed two other even older transactions.

In the picture: green squares - confirmed transactions; red - unconfirmed transactions that confirmed two older transactions; gray - unconfirmed transactions that must confirm two older transactions (they are also called "tips").

The connection between new and old transactions is established using the Monte Carlo method according to the Markov chain scheme (MCMC), which randomizes the transaction selection process for confirmation and ensures that participants will not verify their own transactions.

Unlike the Bitcoin or Ethereum blockchain, where transactions are confirmed by miners in exchange for a reward: a reward for creating a block + a percentage of a transaction is a commission. In Tangle, the function of processing and approving payments is assigned to all active members of the network. Every user who wants to make a transaction confirms two other new transactions and indirectly confirms the entire transaction history.

Thus, the Tangle network is free from the need to pay miners to confirm transactions, as a result of which there are no transaction fees on the network. And since there is no need to create blocks, transactions are confirmed very quickly: the more active participants, the greater the network bandwidth.

To avoid double costs, Tangle (cryptocurrency IOTA) uses a concept called "Illustrated Introduction". Its essence is that the system counts all transactions of the user and does not allow him to spend the same coin twice. If the user has two unconfirmed transactions, the amount of which exceeds his balance, the system selects a chain with more "tips". Chain with a lower rating "cuts off".

The impact of the number of users on the bandwidth and Tangle network bandwidth (IOTA). Source of the image

The combination of DAG and Illustrated Introduction provides Tangle-based projects with a large potential for scaling, because unlike the blockchain, where are limitations on network bandwidth, the power of the Tangle network increases with the number of active users. At the moment, the speed of the largest networks Tangle, IOTA and Nano is 1000 and 7000 TPS, accordingly.

Hashgraph: the latest generation of DLT

Hashgraph is another way to build a distribution ledger (DLT). It was developed by Leemon Baird in mid-2016, focusing on the needs of the private corporate sector. Intellectual property on Hashgraph is owned by Swirlds, so the software for creating private DLTs is called Swirlds Hashgraph.

Advantages of Swirlds Hashgraph:

speed - up to 100,000 transactions per second;

immutability of transaction history;

resistance to DDoS attacks;

disposable DLT.

Swirlds Hashgraph is not a blockchain, so cryptocurrency HYIP has bypassed technology. But it was noticed by banks: a consortium of 6,000 banks in North America, formed by the Union National Association (CUNA) and the Mountain West Credit Union Association (MWCUA), chose Swirlds Hashgraph to create a corporate network common to all.

Thanks to this success, Swirlds decided to launch the Hedera Hashgraph Platform. In fact, this is an analogue of the Ethereum network, only without the traditional blockchain and with a different management model. At the top of the food chain of the platform is the Hedera Governing Council, which has 39 members (private and legal entities), and they will determine the path of development of the project. Swirlds management picks board members. Five council members are already selected: T-Labs, DLA Piper, Nomura Holdings, Swisscom Blockchain and Luiza magazine.

Thus, the management of Hedera Hashgraph will be carried out according to the type of a multinational company (consortium), which more closely resembles the Visa management model, rather than Bitcoin and Ethereum. The same applies to intellectual property: hard forks in the Hedera Hashgraph network are impossible, because the software is protected by copyright.

How Hedera Hashgraph Works

As with Tangle, Hedera Hashgraph is not a blockchain. Unlike the blockchain, where information is stored in blocks, Hedera Hashgraph information is stored in hashes (hence the name "hashgraph"), which describe certain "events".

Within each event, transaction records that are known to one participant and supposedly unknown to other participants: a timestamp, two different parent hashes, and one or more transactions. Like Tangle, Hashgraph creates an extensive pattern from events (or transactions), where transactions are arranged in chronological order, so that their history can be traced.

The operation of the platform and the exchange of hashes between participants takes place via the Gossip protocol: when an event occurs, the node transmits data to it to two other random nodes, which transmit them to two other nodes (in the total already four), and so on. This leads to an exponential spread of information throughout the network.

However, simply distributing information is not enough to reach a consensus on the total amount of information on the network. To do this, each participant in the system (node) must know the transaction history, that is, the exact chronology of all individual transactions (transaction timestamps).

In Hashgraph, the "Gossip about Gossip" consensus algorithm is responsible for this: each node on the network shares all of its information about which node, when and with whom it communicated or, technically speaking, each device shares its own data on the hash graph (exact order of all transactions ever performed on the Hedera Hashgraph network).

Since each node always has a current hash graph, it always knows the entire transaction history. This circumstance makes it possible for Hashgraph to be called "virtual voting": since all nodes have a copy of transaction history and information about who received the information at a given time, each node can calculate how the other nodes behave.

That is, each node knows in advance the decision of the other without making an active, effective decision (vote). This "vote without a vote" and allows you to reach a network of consensus. In a short time and without the need for a resource-intensive procedure for coordinating nodes among themselves.

Mathematical proof of stability

Interestingly, the consensus algorithm used in the Hedera Hashgraph network has been used in practice for more than 35 years (in a slightly different form). And it is so well made that it has a "mathematically confirmed level of security." That is, according to mathematical calculations, it is very difficult (if not impossible) to outwit.

That is why the developers of Hedera Hashgraph cite mathematical proofs of reliability, saying that their network is the only DLT technology with asynchronous Byzantine error tolerance (A-BFT, or aBFT). This means that while less than one third of the network participants do not want to fool the network, the system can always find a consensus on the network status and transaction history. This is considered to be the highest degree of security that an algorithm of consensus can provide.

The future of Hedera Hashgraph

Safety. As a form of DTL, Hashgraph can change the structure of the modern Internet. The fact is that the Internet in its current form has a number of birth defects, the main of which is centralized servers and centralized data storage. It is because of this defect that hackers, BotNet, hacks, spam and DDoS attacks became part of the daily life of any Internet user.

Hashgraph can "cure" this defect by creating ecosystems where information is stored in the clear and is protected from hackers, falsification and DDoS attacks. Such systems will be able to serve anything - from the school network to the Pentagon's security system. And almost everyone will be able to run them.

System isolation. In addition to the problem of security, the developers of Hedera Hashgraph also insist that they can solve the problem of isolating the Internet. Now the world wide web consists of a large number of isolated worlds (operating systems, devices, programs and web platforms), which by default are not connected with each other.

In order to connect these worlds, bridges are built between them (communication protocols, API), which are focused not so much on efficiency as on security. Therefore, such bridges are very resource intensive. If these worlds are built on the basis of Hedera Hashgraph, the need for bridges will disappear, and the connection between them will be carried out by default.
Scalability. Unlike traditional blockchain protocols, Hashgraph will allow you to create ecosystems with unlimited potential for scalability.

This will be possible due to two things:

the capacity of Hedera Hashgraph-based systems increases with the number of active participants;

members of Hedera Hashgraph-based networks will receive rewards for using the resources of their devices.

Paying for the use of resources is important because it will allow the network to be distributed among the devices of ordinary users, rather than centralized high-budget server stations. This will reduce the centralization of the system and at the same time increase the level of its security, since the more participants, the harder it is to hack the network.

This also contributes to the fact that the node in Hedera Hashgraph does not require a large amount of resources: disk space for storing transaction history (as in the Bitcoin and Ethereum blockchain), a powerful processor or video card for mining. The node in the Hedera Hashgraph can be a regular smartphone, and even its resources will not be fully utilized.

Internet speed and ping. Modern Internet seems to us quite fast compared to speeds that were 5 or 10 years ago. However, if you replace centralized servers that route data through the entire system with DLT-based networks, the connection speed between devices connected to the network will increase. Just few extra links will dissapedear.

In addition, DLT technologies will also allow ping to be minimized, since the devices will communicate either with each other or through a minimum number of intermediaries. For ordinary people, a gain of 10-30 milliseconds will not play a big role, but for the banking, medical and public sectors this will be a very big plus. As for all fans of virtual games.

# data[].attributes.attachment_link.title
What is the Difference Between Hedera Hashgraph vs Blockchain vs Tangle - Merehead

# data[].attributes.attachment_link.description
Bitcoin cryptocurrency blockchain is usually considered as the original blockchain of version 1.0, since this is the first modern implementation of the distributed ledger technology (DLT). Over time, blockchain 1.0 has evolved into Ethereum, which is considered to be the blockchain version 2.0.

# data[].attributes.attachment_link.description
For too long it has been extraordinarily difficult, even for leading developers, to fork the Bitcoin blockchain. The need to change source code and to use a compiler has been an excessive burden. Forkgen was created to allow innovation to break free of the central planning stranglehold of Core.

# data[].attributes.attachment_link.readable_text
As part of my own education process, I wanted to create my own Ethereum token that would be viable to sell on an exchange. ICOs are all the rage these days, and I see them as a valuable avenue to raising funds for important projects in the world.

Thus The Most Private Coin Ever was born.

Since I've launched the coin, I've gotten a lot of messages from people asking me how they can do the same. They've wanted to create their own token for fun, to learn, or for a business that they're starting...

...but they don't know where to start.

The challenge with programming in Ethereum is that their aren't a ton of resources out there for how to do things. It's still pretty new, with limited documentation and Stack Overflow responses.

And so in this tutorial, I'm going to make it simple.

I'm going to show you how to create your own Ethereum Token in as little as one hour, so you can use it for your own projects.

This token will be a standard ERC20 token, meaning you'll set a fixed amount to be created and won't have any fancy rules. I'll also show you how to get it verified so that it's uber legit.

Let's get started.

Step 1: Decide what you want your token to be

In order to create an ERC20 token, you need the following:

The Token's Name

The Token's Symbol

The Token's Decimal Places

The Number of Tokens in Circulation

For The Most Private Coin Ever , I chose:

Name: The Most Private Coin Ever

Symbol: ???

Decimal Places: 0

Amount of Tokens in Circulation: 100,000

The decimal places is where things can get tricky. Most tokens have 18 decimal places, meaning that you can have up to .0000000000000000001 tokens.

When creating the token, you'll need to be aware of what decimal places you'd like and how it fits into the larger picture of your project.

For me, I wanted to keep it simple and wanted people to either have a token, or not. Nothing in between. So I chose 0. But you could choose 1 if you wanted people to have half a token, or 18 if you wanted it to be 'standard'.

Step 2: Code the Contract

Here is a contract that you can essentially "Copy/Paste" to create your ERC20 token. Shoutout to TokenFactory for the source code.

pragma solidity ^0.4.4; contract Token { /// @return total amount of tokens function totalSupply() constant returns (uint256 supply) {} /// @param _owner The address from which the balance will be retrieved /// @return The balance function balanceOf(address _owner) constant returns (uint256 balance) {} /// @notice send `_value` token to `_to` from `msg.sender` /// @param _to The address of the recipient /// @param _value The amount of token to be transferred /// @return Whether the transfer was successful or not function transfer(address _to, uint256 _value) returns (bool success) {} /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` /// @param _from The address of the sender /// @param _to The address of the recipient /// @param _value The amount of token to be transferred /// @return Whether the transfer was successful or not function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {} /// @notice `msg.sender` approves `_addr` to spend `_value` tokens /// @param _spender The address of the account able to transfer the tokens /// @param _value The amount of wei to be approved for transfer /// @return Whether the approval was successful or not function approve(address _spender, uint256 _value) returns (bool success) {} /// @param _owner The address of the account owning tokens /// @param _spender The address of the account able to transfer the tokens /// @return Amount of remaining tokens allowed to spent function allowance(address _owner, address _spender) constant returns (uint256 remaining) {} event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract StandardToken is Token { function transfer(address _to, uint256 _value) returns (bool success) { //Default assumes totalSupply can't be over max (2^256 - 1). //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap. //Replace the if with this one instead. //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { if (balances[msg.sender] >= _value && _value > 0) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } } function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { //same as above. Replace this line with the following if you want to protect against wrapping uints. //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint256 public totalSupply; } //name this contract whatever you'd like contract ERC20Token is StandardToken { function () { //if ether is sent to this address, send it back. throw; } /* Public variables of the token */ /* NOTE: The following variables are OPTIONAL vanities. One does not have to include them. They allow one to customise the token contract & in no way influences the core functionality. Some wallets/interfaces might not even bother to look at this information. */ string public name; //fancy name: eg Simon Bucks uint8 public decimals; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether. string public symbol; //An identifier: eg SBX string public version = 'H1.0'; //human 0.1 standard. Just an arbitrary versioning scheme. // // CHANGE THESE VALUES FOR YOUR TOKEN // //make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token function ERC20Token( ) { balances[msg.sender] = NUMBER_OF_TOKENS_HERE; // Give the creator all initial tokens (100000 for example) totalSupply = NUMBER_OF_TOKENS_HERE; // Update total supply (100000 for example) name = "NAME OF YOUR TOKEN HERE"; // Set the name for display purposes decimals = 0; // Amount of decimals for display purposes symbol = "SYM"; // Set the symbol for display purposes } /* Approves and then calls the receiving contract */ function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this. //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData) //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead. if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; } return true; } }

Throw this into your favorite text editor ( Sublime is my personal favorite).

You're going to want to replace everything in the area where it says "CHANGE THESE VARIABLES FOR YOUR TOKEN".

So that means, change:

The token name

The token symbol (I'd go no more than 4 characters here)

The token decimal places

How much you as the owner want to start off with

The amount of tokens in circulation (to keep things basic, make this is the same amount as the owner supply)

Some things to keep in mind:

The supply that you set for the token is correlated to the amount of decimal places that you set.

For example, if you want a token that has 0 decimal places to have 100 tokens, then the supply would be 100.

But if you have a token with 18 decimal places and you want 100 of them, then the supply would be 100000000000000000000 (18 zeros added to the amount).

You set the amount of tokens you receive as the creator of the contract.

That's what this line of code is:

balances[msg.sender] = NUMBER_OF_TOKENS_HERE;

Whatever you set here will be sent to the ETH wallet of wherever you deploy the contract. We'll get to that in a few.

But for now just set this equal to the supply so that you receive all the tokens. If you're wanting to be more advanced with the token logic, you could set it with different rules, like different founders of your projects would receive different amounts or something like that.

Once you have all the variables in, it's now time to deploy it to the blockchain and test it.

Step 3: Test The Token on The TestNet

Next we're going to deploy the contract to the Test Net to see if it works. It sucks to deploy a contract to the MainNet, pay for it, and then watch it fail.

I may have done that while creating my own token....so heed the warning.

First, if you don't have it already, download MetaMask. They have an easy-to-use interface to test this.

Once you've installed MetaMask, make sure that you're logged in and setup on the Ropsten test network. If you click in the top left where it says 'Main Ethereum Network' you can change it to Ropsten.

To confirm, the top of your MetaMask window should look like this:
This Wallet is going to be the 'Owner' of the contract, so don't lose this wallet! If you'd like it not to be Metamask, you can use Mist or MyEtherWallet to create contracts as well. I recommend using MM for simplicity, and you can always export your private key to MyEtherWallet for usage later.
Now head to the Solidity Remix Compiler - it's an online compiler that allows you to publish the Smart Contract straight to the blockchain.

Copy/Paste the source of the contract you just modified into the main window. It'll look something like this:

Now, go to settings on the right and select the latest release compiler version (NOT nightly), as well as unchecking 'Enable Optimization'.

So it should look something like this:

Keep note of the current Solidity version in the compiler. We'll need that later to verify the contract source.

Now go back to the Contract tab and hit 'Create' under the name of the Token function that you created.

So you'd hit 'Create' under 'TutorialToken'.

What will happen is MetaMask will pop up asking you to hit 'Submit' to pay for the transaction.

Remember, this is the Ropsten test net, so it's not real Ether. You can double check to make sure you're on the test network in MetaMask before you hit submit just to be sure.

When you hit Submit, it'll say 'Contract Pending' in MetaMask. When it's ready, click the 'Date' and it'll bring up the transaction in EtherScan. Like this:

If you click the date, it'll bring up the following screen:

If this process worked, it's now time to verify the source code.

If not, you'll want to go back to the code and modify the source to get it to work.

I can't say exactly what that'd look like, but this is where having a "programmers mindset" comes in. A lot of time there's unexpected bugs that can't be predicted until you just do it.

Step 3.5. Watch The Custom Token

Now let's see if it actually created the tokens and sent them to me.

Copy the Contract Address that's listed in the Transaction information (see screenshot above).

In this case, for me, it's 0x5xxxxxxxxxxxxxxxx.

I'm going to add that to MetaMask 'Tokens' tab:

When I click the "+" button, I can paste it in there and it'll automatically insert the information of the token, like so:

Let's hit 'Add'.

Sweet! It says I have the 100 tokens that I created - it worked!

Now I can send those tokens, or sell them on a market if I decide to do so.

Boo ya!

Step 4. Verify the Source Code

This is going to be important for various reasons, mainly verifying the validity of your token to the public.

It doesn't technically matter, and your token will still be usable if you don't do it, but it's good practice to verify it so people know that you're not doing anything shady.

When you're on the Transaction screen from the previous step, click where it says [Contract xxxxxx Created] in the To: field. That's the Contract we just published.

Then click the 'Contract Code' tab.

Hit 'Verify and Publish'. That'll bring you to this screen:

Here's where you NEED to have the right settings.

The Contract Address will already be filled in.

For Contract Name, make sure to put the name of the function that you modified for your custom token. The default in the code I gave you is ERC20Token, but if you renamed it, make sure you put that.

I renamed mine 'TutorialToken' for this tutorial, so I put that.

For Compiler, select the SAME compiler you used in the Solidity Compiler. Otherwise you will not be able to verify your source code!

Make sure Optimization is disabled as well.

Then Copy/Paste the code from the compiler right into the Contract Code field (the big one).

Hit submit.

If you did the steps right, you'll get something like this:

That means it was verified. Woot!

If you go to the Contract address page, you'll see that 'Contract Source' says Yes and says that it's Verified. Like this:

If not, double check your steps, or make a comment in this thread and we'll see what went wrong.

Step 5. Get it on The Main Net

Now that everything's working, it's time to deploy it on the MainNet and let other people use it.

This part is simple.

Just do steps 3 & 4, but instead of being connected to the Ropsten Test Network, you want to be connected to the MainNet. Make sure your MetaMask account is in Mainnet mode.

You'll need to fund your contract with real Ether to do this. This cost me ~$30 USD when I did this for The Most Private Coin Ever

Step 6. Get it Verified on Etherscan

This step is not required, but it adds to the validity of your token if you get it verified by them.

You can see how my token is verified by how it has the logo and it doesn't say "UNVERIFIED" next to it.
Click here to see what I mean
To do this you'll need to go to the Etherscan Contact Us Page) and send them an e-mail with the following information:

1. Ensure that you token contract source code has been verified 2. Provide us with your Official Site URL: 3. Contract Address: 4. Link to download a 28x28png icon logo:

So yes, you'll need to have a website with a stated purpose of the token.

They'll get back to you and let you know if they'll verify it or not. Remember, Etherscan is a centralized service so it's very possible that they will not verify your token if they don't deem it worthy.

Congrats! & Next Steps

You now have a token on the ETH MainNet that other people can use. It's now primed to be sent to others and received.

To buy and sell, you'll need to get your token listed on an exchange. But that's a tutorial for another day :)

For now, enjoy your newly created (and personal) ERC20 & Verified Ethereum Token!!

Follow me at @maxnachamkin to get notified when new tutorials and reports come out.

To freedom,

Max

EDIT: It's been 3 years since the original post - it's likely that the contract code has updated so that will no longer work. If you'd like to create your own token with MyEtherWallet, the same process will still work you just need to find that new contract code. Since then I've heard about some tools that do this for you - Guarda & WAVES are two that I've heard of (but haven't tried).

# data[].attributes.attachment_link.title
How To Create Your Own Ethereum Token In An Hour (ERC20 + Verified) - Steemit

# data[].attributes.attachment_link.description
As part of my own education process, I wanted to create my own Ethereum token that would be viable to sell on an exchange. ICOs are all the rage these days, and I see them as a valuable avenue to raising funds for important projects in the world.

# data[].attributes.attachment_link.title
Bitcoin's Lightning Network, Simply Explained!

# data[].attributes.attachment_link.description
Bitcoin has a 7 transaction/second limit, so how can we overcome this? The Lightning Network is one of the proposals and in this video I'll explain how it works. 💰 Want to buy Bitcoin or Ethereum?

# data[].attributes.attachment_link.title
HASHGRAPH INTERVIEW! PAUL MADSEN FROM SWIRLDS!

# data[].attributes.body
7 Network Effects

# data[].attributes.attachment_link.readable_text
Enjoy this graphic? You can also find it in our new infographic book - it's available until Oct 31st, 2017 on Kickstarter.
Millions, billions, and trillions...

When we talk about the giant size of Apple, the fortune of Warren Buffett, or the massive amount of global debt accumulated - all of these things sound large, but they are actually extremely different in magnitude.

That's why visualizing things spatially can give us a better perspective on money and markets.

How Much Money Exists?

This infographic was initially created to show how much money exists in its different forms. For example, to highlight how much physical cash there is in comparison to broader measures of money which include saving and checking account deposits.

Interestingly, what is considered "money" depends on who you are asking.

Are the abstractions created by Central Banks really money? What about gold, bitcoins, or other hard assets?

A New Meaning

However, since we first released this infographic in 2015, "All the World's Money and Markets" has taken on a different meaning to us and many others. It's a way of simplifying a complex universe of currencies, assets, and other financial instruments in a way that people can understand.

Numbers represented in the data visualization range from the size of the above-ground silver market ($17 billion) to the notional value of all derivatives ($1.2 quadrillion as a high-end estimate). In between those two extremes, we've added many other familiar measures, such as the GDP of California, the value of equities, the real estate market, along with different money supply metrics to give perspective.

The end result? A visually pleasing, but enlightening new way to understand the vast universe of global assets.
To get "All the World's Money" in book or poster form, go to the Kickstarter page now. Deadline: Oct. 31, 2017
About the Money Project

The Money Project uses intuitive visualizations to explore ideas around the very concept of money itself. Founded in 2015 by Visual Capitalist and Texas Precious Metals, the Money Project will look at the evolving nature of money, and will try to answer the difficult questions that prevent us from truly understanding the role that money plays in finance, investments, and accumulating wealth.

# data[].attributes.attachment_link.title
All the World's Money and Markets in One Visualization

# data[].attributes.attachment_link.description
Enjoy this graphic? You can also find it in our new infographic book - it's available until Oct 31st, 2017 on Kickstarter. Millions, billions, and trillions... When we talk about the giant size of Apple, the fortune of Warren Buffett, or the massive amount of global debt accumulated - all of these things sound large, but they are actually extremely different in magnitude.

# data[].attributes.attachment_link.title
Proof of WHAT?! Overview of 13 different consensus algorithms for cryptocurrencies!

# data[].attributes.attachment_link.title
Hedge Fund Millionaire Invests All His Money in Bitcoin | Raoul Pal | Pomp Podcast #444

# data[].attributes.body
Portfolios of disruptive tech

# data[].attributes.attachment_link.title
Next Generation Internet Investment Strategy by ARK Invest

# data[].attributes.attachment_link.description
This actively managed equity strategy seeks long-term capital growth by investing in the US listed securities, including ADRs, of companies focused on next generation internet.