Convert Figma logo to code with AI

Consensys logoquorum

A permissioned implementation of Ethereum supporting data privacy

4,680
1,291
4,680
75
View on GitHub

Top Related Projects

ethereum's avatar

go-ethereum

47,370

Go implementation of the Ethereum protocol

hyperledger's avatar

besu

1,493

An enterprise-grade Java-based, Apache 2.0 licensed Ethereum client https://wiki.hyperledger.org/display/besu

hyperledger's avatar

fabric

15,696

Hyperledger Fabric is an enterprise-grade permissioned distributed ledger framework for developing solutions and applications. Its modular and versatile design satisfies a broad range of industry use cases. It offers a unique approach to consensus that enables performance at scale while preserving privacy.

paritytech's avatar

substrate

8,384

Substrate: The platform for blockchain innovators

stellar's avatar

stellar-core

3,122

Reference implementation for the peer-to-peer agent that manages the Stellar network.

Quick Overview

Quorum is an enterprise-focused version of Ethereum, developed by ConsenSys. It's designed to provide privacy, permissioning, and enhanced performance for blockchain applications in business environments. Quorum maintains compatibility with Ethereum while introducing features specifically tailored for enterprise use cases.

Pros

  • Enhanced privacy with private transactions and private contracts
  • Improved performance and scalability compared to public Ethereum
  • Permissioned network support for enterprise-grade security
  • Compatibility with Ethereum tools and smart contracts

Cons

  • Less decentralized than public Ethereum networks
  • Requires more complex setup and management compared to public chains
  • May have a steeper learning curve for developers familiar with public Ethereum
  • Limited ecosystem compared to public Ethereum

Code Examples

Here are a few examples of how to interact with Quorum:

  1. Deploying a private contract:
const Web3 = require('web3');
const web3 = new Web3('http://localhost:22000');

const privateContract = new web3.eth.Contract(abi);
const deployTx = privateContract.deploy({
    data: bytecode,
    arguments: [constructor_arguments]
});

const privateFor = ["ROAZBWtSacxXQrOe3FGAqJDyJjFePR5ce4TSIzmJ0Bc="];
const deployedContract = await deployTx.send({
    from: account,
    gas: 4700000,
    privateFor: privateFor
});
  1. Sending a private transaction:
const privateTransaction = await web3.eth.sendTransaction({
    from: account1,
    to: account2,
    value: web3.utils.toWei('1', 'ether'),
    privateFor: ["ROAZBWtSacxXQrOe3FGAqJDyJjFePR5ce4TSIzmJ0Bc="]
});
  1. Reading a private state:
const privateContract = new web3.eth.Contract(abi, contractAddress);
const result = await privateContract.methods.someMethod().call({
    from: account,
    privateFor: ["ROAZBWtSacxXQrOe3FGAqJDyJjFePR5ce4TSIzmJ0Bc="]
});

Getting Started

To get started with Quorum:

  1. Install Quorum:
git clone https://github.com/ConsenSys/quorum.git
cd quorum
make all
  1. Set up a Quorum network (using Quorum Wizard):
npx quorum-wizard
  1. Connect to your Quorum node using Web3.js:
const Web3 = require('web3');
const web3 = new Web3('http://localhost:22000');
  1. Start developing your dApp using Quorum's privacy features and enterprise-focused capabilities.

Competitor Comparisons

ethereum logo

go-ethereum

47,370

Go implementation of the Ethereum protocol

Pros of go-ethereum

  • Larger community and more extensive development history
  • Broader compatibility with Ethereum ecosystem tools and applications
  • More frequent updates and improvements

Cons of go-ethereum

  • Less focus on privacy and permissioning features
  • Higher resource requirements for running nodes

Code Comparison

go-ethereum:

func (s *Ethereum) Start() error {
    // Start the various components
    if err := s.startEthService(); err != nil {
        return err
    }
    return nil
}

Quorum:

func (s *Ethereum) Start() error {
    // Start the various components
    if err := s.startQuorumService(); err != nil {
        return err
    }
    return nil
}

The code snippets show similar structure but highlight Quorum's focus on its specialized services. While go-ethereum initializes standard Ethereum components, Quorum adds its own services tailored for privacy and permissioning.

go-ethereum serves as the reference implementation for Ethereum, offering broad compatibility and frequent updates. It benefits from a larger community and more extensive development history. However, it lacks some of the privacy and permissioning features found in Quorum.

Quorum, built on go-ethereum, focuses on enterprise use cases with enhanced privacy and permissioning. It offers features like private transactions and network governance but may have a smaller community and less frequent updates compared to go-ethereum.

hyperledger logo

besu

1,493

An enterprise-grade Java-based, Apache 2.0 licensed Ethereum client https://wiki.hyperledger.org/display/besu

Pros of Besu

  • More active development and larger community support
  • Better documentation and easier onboarding for new users
  • Supports both permissioned and permissionless networks

Cons of Besu

  • Higher resource requirements for running nodes
  • Slower transaction processing compared to Quorum
  • Less focus on privacy features

Code Comparison

Besu (Java):

public class BesuController {
    private final Blockchain blockchain;
    private final ProtocolSchedule protocolSchedule;
    private final EthProtocolManager ethProtocolManager;
    // ...
}

Quorum (Go):

type QuorumEthService struct {
    blockchain      *core.BlockChain
    txPool          *core.TxPool
    contractBackend *backends.SimulatedBackend
    // ...
}

Both projects aim to provide enterprise-grade Ethereum clients, but they differ in their implementation languages and specific features. Besu, written in Java, offers broader network support and better documentation. Quorum, implemented in Go, focuses more on privacy and performance for permissioned networks. The code snippets show the core controller/service structures for each project, highlighting their different approaches to managing blockchain components.

hyperledger logo

fabric

15,696

Hyperledger Fabric is an enterprise-grade permissioned distributed ledger framework for developing solutions and applications. Its modular and versatile design satisfies a broad range of industry use cases. It offers a unique approach to consensus that enables performance at scale while preserving privacy.

Pros of Fabric

  • More flexible and modular architecture, allowing for customizable components
  • Supports multiple programming languages for smart contracts (chaincode)
  • Better scalability and performance for enterprise-level applications

Cons of Fabric

  • Steeper learning curve due to complex architecture
  • Less compatibility with existing Ethereum-based tools and applications
  • Requires more setup and configuration compared to Quorum

Code Comparison

Fabric chaincode (Go):

func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface, id string, value int) error {
    asset := Asset{ID: id, Value: value}
    assetJSON, err := json.Marshal(asset)
    if err != nil {
        return err
    }
    return ctx.GetStub().PutState(id, assetJSON)
}

Quorum smart contract (Solidity):

pragma solidity ^0.8.0;

contract SimpleStorage {
    uint private storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public view returns (uint) {
        return storedData;
    }
}

Both Fabric and Quorum are enterprise-focused blockchain platforms, but they differ in their approach and architecture. Fabric offers more flexibility and language support, while Quorum provides easier integration with Ethereum-based tools and a simpler setup process. The choice between them depends on specific project requirements and existing infrastructure.

paritytech logo

substrate

8,384

Substrate: The platform for blockchain innovators

Pros of Substrate

  • More flexible and customizable blockchain framework
  • Better suited for building diverse blockchain applications beyond just financial use cases
  • Supports multiple consensus mechanisms out-of-the-box

Cons of Substrate

  • Steeper learning curve due to its more complex architecture
  • Smaller ecosystem and community compared to Ethereum-based solutions
  • Less focus on enterprise features and permissioned networks

Code Comparison

Substrate (Rust):

#[pallet::weight(10_000 + T::DbWeight::get().writes(1))]
pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResult {
    let who = ensure_signed(origin)?;
    <Something<T>>::put(something);
    Self::deposit_event(Event::SomethingStored(something, who));
    Ok(())
}

Quorum (Go):

func (c *SimpleStorage) Set(s *types.Transaction) (string, error) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.storedData = s.Data()
    return c.storedData, nil
}

The code snippets showcase the different programming languages and approaches used in each project. Substrate uses Rust and a more declarative style, while Quorum uses Go and follows Ethereum's smart contract patterns.

stellar logo

stellar-core

3,122

Reference implementation for the peer-to-peer agent that manages the Stellar network.

Pros of stellar-core

  • Faster transaction processing and higher throughput
  • More energy-efficient consensus mechanism (Stellar Consensus Protocol)
  • Better suited for cross-border payments and remittances

Cons of stellar-core

  • Less flexible smart contract capabilities
  • Smaller developer ecosystem compared to Ethereum-based platforms
  • More centralized governance model

Code Comparison

stellar-core (C++):

void LedgerTxn::addChild(AbstractLedgerTxn& child)
{
    if (mChild)
    {
        throw std::runtime_error("LedgerTxn already has child");
    }
    mChild = &child;
}

quorum (Go):

func (s *StateDB) AddBalance(addr common.Address, amount *big.Int) {
    stateObject := s.GetOrNewStateObject(addr)
    if stateObject != nil {
        stateObject.AddBalance(amount)
    }
}

The code snippets show different approaches to managing state and transactions. stellar-core uses a ledger transaction system, while quorum follows Ethereum's account-based model. This reflects the different design philosophies and use cases of the two platforms.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Build Check Docker Pulls Discord

GoQuorum is an Ethereum-based distributed ledger protocol with transaction/contract privacy and new consensus mechanisms.

GoQuorum is a fork of go-ethereum and is updated in line with go-ethereum releases.

Key enhancements over go-ethereum:

  • Privacy - GoQuorum supports private transactions and private contracts through public/private state separation, and utilises peer-to-peer encrypted message exchanges (see Tessera) for directed transfer of private data to network participants
  • Alternative Consensus Mechanisms - with no need for POW/POS in a permissioned network, GoQuorum instead offers multiple consensus mechanisms that are more appropriate for consortium chains:
    • QBFT - Improved version of IBFT that is interoperable with Hyperledger Besu
    • Istanbul BFT - a PBFT-inspired consensus algorithm with transaction finality, by AMIS.
    • Clique POA Consensus - a default POA consensus algorithm bundled with Go Ethereum.
    • Raft-based Consensus - a consensus model for faster blocktimes, transaction finality, and on-demand block creation
  • Peer Permissioning - node/peer permissioning, ensuring only known parties can join the network
  • Account Management - GoQuorum introduced account plugins, which allows GoQuorum or clef to be extended with alternative methods of managing accounts including external vaults.
  • Pluggable Architecture - allows adding additional features as plugins to the core geth, providing extensibility, flexibility, and distinct isolation of GoQuorum features.
  • Higher Performance - GoQuorum offers significantly higher performance throughput than public geth

Architecture

GoQuorum Tessera Privacy Flow

The above diagram is very high-level overview of component architecture used by GoQuorum. For more in-depth discussion of the components and how they interact, please refer to lifecycle of a private transaction.

Quickstart

The easiest way to get started is to use * quorum-dev-quickstart - a command line tool that allows users to set up a development GoQuorum network on their local machine in less than 2 minutes.

GoQuorum Projects

Check out some of the interesting projects we are actively working on:

Official Docker Containers

The official docker containers can be found under https://hub.docker.com/u/quorumengineering/

Third Party Tools/Libraries

The following GoQuorum-related libraries/applications have been created by Third Parties and as such are not specifically endorsed by J.P. Morgan. A big thanks to the developers for improving the tooling around GoQuorum!

Contributing

GoQuorum is built on open source and we invite you to contribute enhancements. Upon review you will be required to complete a Contributor License Agreement (CLA) before we are able to merge. If you have any questions about the contribution process, please feel free to send an email to info@goquorum.com. Please see the Contributors guide for more information about the process.

Reporting Security Bugs

Security is part of our commitment to our users. At GoQuorum we have a close relationship with the security community, we understand the realm, and encourage security researchers to become part of our mission of building secure reliable software. This section explains how to submit security bugs, and what to expect in return.

All security bugs in GoQuorum and its ecosystem (Tessera, Cakeshop, ..etc) should be reported by email to security-quorum@consensys.net. Please use the prefix [security] in your subject. This email is delivered to GoQuorum security team. Your email will be acknowledged, and you'll receive a more detailed response to your email as soon as possible indicating the next steps in handling your report. After the initial reply to your report, the security team will endeavor to keep you informed of the progress being made towards a fix and full announcement.

If you have not received a reply to your email or you have not heard from the security team please contact any team member through GoQuorum slack security channel. Please note that GoQuorum discord channels are public discussion forum. When escalating to this medium, please do not disclose the details of the issue. Simply state that you're trying to reach a member of the security team.

Responsible Disclosure Process

GoQuorum project uses the following responsible disclosure process:

  • Once the security report is received it is assigned a primary handler. This person coordinates the fix and release process.
  • The issue is confirmed and a list of affected software is determined.
  • Code is audited to find any potential similar problems.
  • If it is determined, in consultation with the submitter, that a CVE-ID is required, the primary handler will trigger the process.
  • Fixes are applied to the public repository and a new release is issued.
  • On the date that the fixes are applied, announcements are sent to Quorum-announce.
  • At this point you would be able to disclose publicly your finding.

Note: This process can take some time. Every effort will be made to handle the security bug in as timely a manner as possible, however it's important that we follow the process described above to ensure that disclosures are handled consistently.

Receiving Security Updates

The best way to receive security announcements is to subscribe to the Quorum-announce mailing list/channel. Any messages pertaining to a security issue will be prefixed with [security].

Comments on This Policy If you have any suggestions to improve this policy, please send an email to info@goquorum.com for discussion.

License

The go-ethereum library (i.e. all code outside of the cmd directory) is licensed under the GNU Lesser General Public License v3.0, also included in our repository in the COPYING.LESSER file.

The go-ethereum binaries (i.e. all code inside of the cmd directory) is licensed under the GNU General Public License v3.0, also included in our repository in the COPYING file.

Any project planning to use the crypto/secp256k1 sub-module must use the specific secp256k1 standalone library licensed under 3-clause BSD.