Digital Transaction Limited
XPLL

Blockchain done right

Meet

ParallelChain®


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 stores crypto assets and biometrics in the ParallelWallet
• An enterprise private blockchain focused on enterprise agility and privacy

ParallelChain

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.

Hybrid
Proof-of-Immutability

• No consensus needed
• Guarantees no forking or mining

Performant
High-performing

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

Provable Immutability
Security

• No duplicate entry
• No data leakage

Interoperable
Migration

Seamless migration from Ethereum and Hyperledger applications

Privacy compliant
Privacy

• 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.

Ethereum

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

Hyperledger

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.

Tamper-proof

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

Bitcoin
Bitcoin1
Ethereum
Ethereum 2.0
Hedra
Hashgraph
Hyperledger
Hyperledger Fabric
Corda
R3 Corda
Polkadot
Polkadot
Parallelchain
ParallelChain® 1.0
Parallelchain
ParallelChain® 2.0
Availability
Now
>2022
Now
Now
Now
Unknown
Now
July 2021
Type of Blockchain
Public
Public
Public
Consortium
Private
Cross-chain
Public + Enterprise
Public + Enterprise + Personal
Transaction Per Second
3+ TPS
1,000 TPS
10,000+ TPS
3,500+ TPS
100 - 1,500 TPS
1,000 TPS (single chain)
100,000+ TPS
100,000+ TPS
Number of Endorser
Unlimited
Up to 64 shards
Unlimited
Performance downgrades beyond 16 endorsers
Dependent on network configuration
Unlimited
Unlimited
Unlimited
Transaction Confirmation
(10-60) * 5 Minutes
5,000 seconds
3-5 seconds
0.1 second
2.5 - 15 seconds
Up to 1 hour
0.005 seconds
0.003 seconds
Data Privacy Compliance
GDPR-compliant
GDPR-compliant
Right to be Forgotten
User Registration: Secured and Trusted Access
N/A
N/A
N/A
2FA
N/A
N/A
2FA + Biometrics
Multi-Biometrics
1 Note: Bitcoin and Ethereum requires (N + 5) transactions in order to confirm the Nth transaction.
Natively supported operating modes

Three modes, countless applications

parallelverse

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 (
	"digital-transaction/pco/parallelcore-apps/apps/commercial-paper/contract/paper"
	"fmt"
	engine "parallelcore-smartcontract-sdk-go/smartcontract_engine"
	"strconv"
	"strings"
)

// 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
}