Yes, Quorum is one open source example.
The Ethereum wiki has a detailed section on Consortium Chain Development including suggestions for consensus algorithms:
In a private chain context, there are three consensus algorithms that
make the most sense:
Proof of authority - essentially, one client with one particular
private key makes all of the ...
There are different algorithms for Proof of Authority. For instance Parity's Authority Round is essentially round robin, where as Rinkeby's version is more complicated. Proof of Authority is not well defined enough to list specific attacks, pick an implementation.
I think an important thing to keep in mind with Proof of Authority is that since the parties ...
Is a blockchain, where we allow only known nodes to participate in the network. Ideally, it is internal for an organisation, a bank per se.
The first primary difference between a properly conceived permissioned blockchain network and an unpermissioned blockchain network is whether the participants in the ...
They are definitely not used interchangeably since they have a very different meaning/purpose:
Private blockchains are private because of the genesis block they are using. Their blocks do not match with any other blockchains (you cannot link blocks from the main net to blocks of a private net with a different genesis blocks as the block header hashes won't ...
Yes, you're welcome to copy the code and run your own Ethereum-like network. The most famous example along those lines is Ethereum Classic, although it's a bit of a special case because it starts with a version of the Ethereum ledger, and differs by not changing when Ethereum did. You can also start a new ledger, without previous account balances, and you ...
The code is at https://github.com/jpmorganchase/quorum
There are related repos at the parent https://github.com/jpmorganchase, such as quorum-examples, quorum-docs, constellation, and cakeshop.
https://www.jpmorgan.com/country/US/EN/Quorum has a summary and other information such as:
Quorum is an enterprise-focused version of Ethereum.
Quorum is ideal for ...
From JP Morgan released its implementation of a permissioned version of Ethereum, the GitHub repository for Quorum is at https://github.com/jpmorganchase/quorum.
From the repository:
Quorum is an Ethereum-based distributed ledger protocol with transaction/contract privacy and a new consensus mechanism.
QuorumChain - a new consensus ...
The --compiler flag should be the IP of the compilers service rather than the docker-machine hosts ip.
By default you can omit the flag to use the remote hosted compilers.
Since it looks like you're trying to use the local compiler via the docker image, you can use the --local-compilers flag on version 0.12.0 of eris.
For version 0.11.4, you'll need to ...
yes, you could setup your private chain and indicate which nodes are allowed to connect to your blockchain.
1-define the same genesis file and the same network id.
2-use the following options to restrict the allowed node :
--nodiscover : Use this option to make sure that your node is not discoverable by people who do not manually add you.
Monax's ErisDB https://monax.io/platform/db/?redirect_from_eris=true
JPMorgan Quorom https://github.com/jpmorganchase/quorum
And naturally you can run vanilla Ethereum in a private network, making it a permissioned blockchain.
I think it is very hard, because we have to understand whole algorithm and maths behind this coins and implement into any system level language. we need full time developing team for it.
Following things are inevitable
Budget for Marketing
High Level Cloud Server configurations with auto backup
Team of Skilled Developers
Just to add to the previous answer, and to save on problems further down the line, "open-source" is a rather general term when applied to software licensing.
Before embarking on a project based on a fork of the codebase, it'd be prudent to understand the licenses that apply to the different parts of the code, and how they might apply to your use-case. (...
In such setups, you'll be most probably using a Proof of Authority (PoA) consensus algorithm. PoW doesn't make sense in such small setups (not safe + wasting energy).
For instance, when using geth's clique algorithm, you'll have a number of authorities in the network, which are allowed to seal a block. As long as at least 2/3 of these authorities are honest,...
AFAIK, No. Quorum and ethereum are not interoperable. A simple argument will be the consensus algorithm used by these two : quorum uses RAFT and ethereum uses the proof of work. Also, quorumuses extra cryptography tools in order to privatize the viewing of transactions between parties, which is contradictory with ethereum.
Making them tag to each other can ...
Permissioned nodes indicate which nodes are whitelisted for connection.
There is no validation of the list of permissioned nodes at the network level, each node operator sets their own permissioned nodes list.
Since it's a peer-to-peer network, if your node can connect to any node on the network, your node can receive all the blocks.
Provided you are using the same algorithm that ETH uses for your private chain, you will always have to mine in order to create blocks and process transactions.
Since it is a private blockchain, there should not be many miners on the network, and thus the hashing power should be low. Because of this, you are able to mine with a simple CPU and very little ...
Your blockchain is not permissioned, i.e. is uses the same rules as Mainnet. Though, in order to connect to it and use it, one will need to:
Know IP/port of some of your nodes
Be able to connect to your nodes
Have your genesis block (probably it is possible to download it from node)
so Quorum permissioning implementation v1 is explained here: https://github.com/jpmorganchase/quorum/wiki/Security#network-permissioning, note that permissions system in v1 is node based, meaning this is a per-node whitelist of other accesible nodes.
Next version of permissining will be a deeper implementation allowing more than just a connection white list....
permissioned-nodes.json is the white-list of remote nodes that are allowed to connect.
static-nodes.json is the list of remote nodes to which to connect on startup and to which to reconnect on connection loss.
Hence, you'll need both files. IF you only have permissioned-nodes.json and no static-nodes.json your node will not connect to any other node on ...
Polkadot protocol is planning to address some of the interblockchain issues.
You can see early work here:
However the current release supports only inter-blockchain ERC-20 token transfers. Arbitrary message passing, like data related to IP addresses and such, is not yet supported.
Very easy to do actually.
This function is a single entry to modify balances on Ethereum (core/state_transition.go):
// TransitionDb will transition the state by applying the current message and
// returning the result including the the used gas. It returns an error if it
// failed. An error indicates a consensus issue.
func (st *StateTransition) ...
Yes and no...
Yes because a the data in a blockchain is persisted on every node on the blockchain, this therefore makes this data public. There are however ways of encrypting the data to make it "public"(comprehensible) to only the people who have the key to decrypt the data.
Can we have a private blockchain? Absolutely yes. The the ledger/data would be ...
It totally depends on what you want to do with your chain, but:
--nodiscover: Yes, use it. it's computing power used for nothing. It may be very small, but still, you don't want random people to connect.
genesis: Make a "complex" genesis file, not one found on internet and just copied and pasted it.
Restrict ports on your VMs
Depending on what you want ...
Have a look at https://www.jpmorgan.com/global/Quorum Quorum is a Enterprise-ready distributed ledger and smart contract platform which is based on ethereum. Quorum has some additional features like. It can send private transactions and restrict their delivery without breaking the blockchain; this ensures your data is only routed to its intended recipient – ...
As I understand, you can compare it to a system with users having permission levels.
If it just a private blockchain, if someone knows the details about the network (bootnode, genisis file etc) he can join the network and run a full node with all permissions (participate in the consensus , auditing etc.)
But when it's a permissioned blockchain, some ...
Network parameters do not authenticate or authorize nodes joining the network. Anybody can join your network as long as they know IP address of your node.
There are couple of EVM implementations with proper node authentication and authorization
Parity allows you to select different consensus engines which are not based on Proof of Work, such as Aura (Proof of Authority) or Tendermint (Practical Byzantine Fault Tolerance, experimental). They are also referred to as validator engines, because only defined validator sets are allowed to participate in consensus.
This enables you to run a permissioned ...