Digital Transaction Limited

Blockchain done right.



— Your all-in-one blockchain

ParallelChain™ can be configured into three different modes:
• A lightning-fast (>100,000 TPS) public distributed ledger that guarantees high performance with no compromise
• A personal, single-user blockchain that secures biometrics and crypto assets in the ParallelWallet
• An enterprise private blockchain focused on enterprise agility and privacy


Ground-breaking features

Scalability, security and decentralization. Because of their technical and infrastructural limitations, blockchain platforms have had to compromise on at least one of these facets to satisfy the rest; this is known as the Blockchain Trilemma. ParallelChain™'s patent-pending technology changes all that, making it the first truly 'business-native' blockchain, ready to power today's real-world applications and scalable to transform enterprises' digital transformation initiatives.


• No consensus needed
• Guarantees no forking or mining


• Unlimited scalability
• Record-breaking 100,000 transactions per second
• Real-time latency

Provable Immutability

• No duplicate entry
• No data leakage


Seamless migration from Ethereum and Hyperledger applications

Privacy compliant

• Compliant with GDPR and other international data protection laws

Every blockchain claims to be immutable, but how true is this? When forked chains can be deleted and blocks can be altered or removed as a result of collusions among a majority of endorsed nodes, such claim becomes questionable.

Blockchain immutability alone is not sufficient to establish trust. Trust can only be earned and maintained when immutability is continuously proven. ParallelChain™ enables participants to repeatedly and randomly verify the immutability of blocks without compromising the privacy of data owners.

Unlimited scalability

Supports an unlimited number of endorsed parties with zero speed degradation.

Industry-leading throughput

Over 100,000 transactions per second (TPS) for one ParallelChain instance. Scales to n * 100,000 TPS for n ParallelChains.

Real-time updates

Ultra-low latency of ≤ 0.01s, allowing for immediate confirmation of updates.

Duplicate entry prevention

Duplicate entry of data is disallowed by design. Problems related to data duplication, such as double-spending and double-counting, are automatically solved.


The world's second-largest cryptocurrency platform by market capitalization, and the platform which most decentralized applications are built on.


A permissioned blockchain infrastructure developed by the Linux Foundation, and contributed by IBM and Digital Asset.

Ability to forget

Data persisted on ParallelChain™ can be deleted, allowing for the removal of time-sensitive data or unlawful content.


Individual endorsers cannot alter persisted records without notifying all parties, eliminating the possibility of data tampering by collusion.

Data integrity

Third parties can mathematically verify the integrity of the blockchain without reading the entire, potentially sensitive, data.

Light-years ahead

How ParallelChain™ compares

Ethereum 2.0 (>2022)
Hyperledger Fabric
R3 Corda
ParallelChain™ 2.0
Type of Blockchain
Speed (transactions per second)
3+ TPS
1,000 TPS
3,500+ TPS
100 - 1,500 TPS
1,000 TPS (single chain)
100,000+ TPS
Up to 64 shards
Performance downgrades beyond 16 endorsers
Dependent on network configuration
(10-60) * 5 Minutes
5,000 seconds
0.1 second
2.5 - 15 seconds
Up to 1 hour
0.003 Second
Data Privacy Compliance
Security in User Registration & Access
Identity Fusion
1 Note: Bitcoin and Ethereum requires (N + 5) transactions in order to confirm the Nth transaction.
Natively supported operating modes

Three modes, countless applications


Public Mode

Zero performance degradation regardless of the number of nodes, in fact, the more the better.

Efficient and privacy-protected data validation through a unique Proof-of-Immutability (PoIM) algorithm.

Deploy multiple ParallelChains of varying configurations to facilitate cross-platform transactions—a parallel design that overcomes cross-chain vulnerabilities, such as hacks and the difficulty to keep up with the state of heterogeneous blockchains.

Personal Mode

A truly personal, single-user blockchain to ensure your biometrics, crypto assets and transaction records are kept secured and private in your ParallelWallet.

Enterprise Mode

Single blockchain for various applications—ParallelChain™ can be deployed in permissioned and permissionless modes to satisfy the varying needs within a business.

Trustless B2B collaboration where information is effectively shared among participants, while also being protected against data leaks.

Seamless migration from other blockchain platforms.

Seamless Migration from Ethereum and Hyperledger Fabric

Bring your blockchain applications up to the speed of business

Build applications on ParallelChain™

ParallelCore Client Go SDK

package commercialpaper

import (
	engine "parallelcore-smartcontract-sdk-go/smartcontract_engine"

// MySC smart contract instance
type MySC struct{}

// Initialize does nothing in this case
func (sc MySC) Initialize(tr engine.Transaction, in []byte) ([]byte, error) {
	return nil, nil

// Handle calls do<ACTION> on invocation of this
// smart contract.
func (sc MySC) Handle(tr engine.Transaction, in []byte) ([]byte, error) {
	args := strings.Split(string(in), " ")
	action := args[0]

	switch action {
	case "List":
		paperStrRepr, err := doList(paper.TransactionContext{Transaction: tr})
		if err != nil {
			return nil, err

		return paperStrRepr, nil

	case "Issue":
		faceValue, err := strconv.Atoi(args[5])
		if err != nil {
			return nil, fmt.Errorf("faceValue should be an integer. Received: %s 
Error: %v", args[5], err)
		err = issue(paper.TransactionContext{Transaction: tr}, IssueArgs{args[1], args[2], args[3], args[4], faceValue})
		if err != nil {
			return nil, err

		return []byte(fmt.Sprintf("Paper successfully issued")), nil

	case "Buy":
		price, err := strconv.Atoi(args[5])
		if err != nil {
			return nil, fmt.Errorf("price should be an integer. Received: %s 
Error: %v", args[5], err)
		err = buy(paper.TransactionContext{Transaction: tr}, BuyArgs{args[1], args[2], args[3], args[4], price, args[6]})
		if err != nil {
			return nil, err

		return []byte(fmt.Sprintf("Paper successfully bought")), nil

	case "BuyRequest":
		price, err := strconv.Atoi(args[5])
		if err != nil {
			return nil, fmt.Errorf("price should be an integer. Received: %s
 Error: %v", args[5], err)
		err = buyRequest(paper.TransactionContext{Transaction: tr}, BuyRequestArgs{args[1], args[2], args[3], args[4], price, args[6]})
		if err != nil {
			return nil, err

		return []byte(fmt.Sprintf("Paper successfully requested")), nil

	case "Transfer":
		err := transfer(paper.TransactionContext{Transaction: tr}, TransferArgs{args[1], args[2], args[3]})
		if err != nil {
			return nil, err

		return []byte(fmt.Sprintf("Paper successfully transfered")), nil