Huione Docs
White Paper
Developers
Developers
  • Learn
    • Introduction to Huione Chain
    • Getting started with Huione Chain
  • Architecture
    • What is a Huione Chain Cluster?
    • Clusters
      • Huione Chain Clusters
      • RPC Endpoints
      • Benchmark a Cluster
      • Performance Metrics
    • Consensus
      • Synchronization
      • Leader Rotation
      • Fork Generation
      • Managing Forks
      • Turbine Block Propagation
      • Commitment Status
      • Secure Vote Signing
      • Stake Delegation and Rewards
    • Validators
      • Overview
      • TPU
      • TVU
      • Blockstore
      • Gossip Service
      • The Runtime
    • Dex & Swap
      • Trade on dex
      • Trade on swap
  • CLI
    • Command-line Guide
    • Install the Huione Tool Suite
    • Command-line Wallets
      • Command Line Wallets
      • Paper Wallet
      • File System Wallet
      • Support / Troubleshooting
    • Using Huione Chain CLI
    • Connecting to a Cluster
    • Send and Receive Tokens
    • Staking
    • Deploy a Program
    • Offline Transaction Signing
    • Durable Transaction Nonces
    • CLI Usage Reference
  • Developers
    • Get Started
      • Hello World
      • Local development
      • Rust program
    • Core Concepts
      • Accounts
      • Transactions
        • Overview
        • Versioned Transactions
        • Address Lookup Tables
      • Programs
      • Rent
      • Calling between programs
      • Runtime
    • Clients
      • JSON RPC API -1
      • JSON RPC API -2
      • JSON RPC API -3
      • Web3 JavaScript API
      • Web3 API Reference
      • Rust API
    • Writing Programs
      • Overview
      • Developing with Rust
      • Deploying
      • Debugging
      • Program Examples
      • FAQ
    • Native Programs
      • Overview
      • Sysvar Cluster Data
    • Local Development
      • Huione Test Validator
    • Backward Compatibility Policy
    • Anchor Book
      • Introduction
        • What is Anchor
        • Anchor Documentation
        • Prerequisites
      • Getting Started
        • Installation
        • Hello, Anchor!
      • Anchor Programs In-Depth
        • Essentials
          • High-level Overview
          • The Accounts Struct
          • The Program Module
          • Errors
          • Milestone Project - Tic-Tac-Toe
        • Intermediate
          • Cross-Program Invocations
          • PDAs
          • Events
      • Anchor BTS
        • The Discriminator
      • Anchor References
        • Space Reference
        • Javascript Anchor Types Reference
        • CLI Reference
        • Code References
  • Validators
    • Running a Validator
    • Getting Started
      • Validator Requirements
    • Voting Setup
      • Starting a Validator
      • Vote Account Management
      • Staking
      • Monitoring a Validator
      • Publishing Validator Info
      • Failover Setup
      • Troubleshooting
    • Geyser
      • Geyser Plugins
  • Staking
    • Staking on Huione
    • Stake Account Structure
  • Integrations
    • Add Huione to Your Exchange
    • Retrying Transactions
  • Library
    • Introduction
    • Token Program
    • Associated Token Account Program
    • Memo Program
    • Name Service
    • Feature Proposal Program
    • NFT Program
      • Overview
      • Interface
      • Usage Guidelines
        • Create a new NFT-Mint
        • Cast NFT
        • Transfer an NFT
        • Change account status
        • Permission settings
        • Query Interface
        • Continuous casting
        • Change the Mint attribute
      • Operation Overview
        • Create a new NFT-Mint
        • Transfer NFT
        • Destroy
        • Freeze NFT accounts
        • Update
    • Huione multi-sign program
      • Overview
      • Interface
      • Usage Guidelines
        • Create a multi-signature account
        • Create a proposal account
        • Vote proposal
        • Verify Proposal
        • Add-singer
        • Remove-signer
      • Operation Overview
        • Create a multi-signature account
        • Create a proposal account
        • Vote
        • Verify
        • Add-singer
        • Remove-signer
Powered by GitBook
On this page
  • Introduction
  • What is Huione Chain?
  • Why Huione Chain?
  • Documentation Overview
  • What is a Huione Chain Cluster?
  • What are HCs?
  • Disclaimer

Was this helpful?

  1. Learn

Introduction to Huione Chain

Introduction

What is Huione Chain?

Huione Chain is an open source project implementing a new, high-performance, permissionless blockchain.

Why Huione Chain?

It is possible for a centralized database to process 710,000 transactions per second on a standard gigabit network if the transactions are, on average, no more than 176 bytes.

A centralized database can also replicate itself and maintain high availability without significantly compromising that transaction rate using the distributed system technique known as Optimistic Concurrency Control [H.T.Kung, J.T.Robinson (1981)].

At Huione Chain, we are demonstrating that these same theoretical limits apply just as well to blockchain on an adversarial network.

The key ingredient?

Finding a way to share time when nodes cannot rely upon one another.

Once nodes can rely upon time, suddenly ~40 years of distributed systems research becomes applicable to blockchain!

Perhaps the most striking difference between algorithms obtained by our method and ones based upon timeout is that using timeout produces a traditional distributed algorithm in which the processes operate asynchronously, while our method produces a globally synchronous one in which every process does the same thing at (approximately) the same time.

Our method seems to contradict the whole purpose of distributed processing, which is to permit different processes to operate independently and perform different functions.

However, if a distributed system is really a single system, then the processes must be synchronized in some way.

Conceptually, the easiest way to synchronize processes is to get them all to do the same thing at the same time.

Therefore, our method is used to implement a kernel that performs the necessary synchronization--for example, making sure that two different processes do not try to modify a file at the same time.

Processes might spend only a small fraction of their time executing the synchronizing kernel; the rest of the time, they can operate independently--e.g., accessing different files.

This is an approach we have advocated even when fault-tolerance is not required.The method's basic simplicity makes it easier to understand the precise properties of a system, which is crucial if one is to know just how fault-tolerant the system is. [L.Lamport (1984)]

Furthermore, and much to our surprise, it can be implemented using a mechanism that has existed in Bitcoin since day one.

The Bitcoin feature is called nLocktime and it can be used to postdate transactions using block height instead of a timestamp.

As a Bitcoin client, you would use block height instead of a timestamp if you don't rely upon the network.

Block height turns out to be an instance of what's being called a Verifiable Delay Function in cryptography circles.

It's a cryptographically secure way to say time has passed. In Huione Chain, we use a far more granular verifiable delay function, a SHA 256 hash chain, to checkpoint the ledger and coordinate consensus.

With it, we implement Optimistic Concurrency Control and are now well en route towards that theoretical limit of 710,000 transactions per second.

Documentation Overview

The Huione Chain docs describe the Huione Chain open source project, a blockchain built from the ground up for scale.

They cover why Huione Chain is useful, how to use it, how it works.

The goal of the Huione Chain architecture is to demonstrate there exists a set of software algorithms that when used in combination to implement a blockchain, removes software as a performance bottleneck, allowing transaction throughput to scale proportionally with network bandwidth.

The architecture goes on to satisfy all three desirable properties of a proper blockchain: it is scalable, secure and decentralized.

The architecture describes a theoretical upper bound of 710 thousand transactions per second (tps) on a standard gigabit network and 28.4 million tps on 40 gigabit.

Furthermore, the architecture supports safe, concurrent execution of programs authored in general-purpose programming languages such as C or Rust.

What is a Huione Chain Cluster?

A cluster is a set of computers that work together and can be viewed from the outside as a single system.

A Huione Chain cluster is a set of independently owned computers working together (and sometimes against each other) to verify the output of untrusted, user-submitted programs.

A Huione Chain cluster can be utilized any time a user wants to preserve an immutable record of events in time or programmatic interpretations of those events.

One use is to track which of the computers did meaningful work to keep the cluster running. Another use might be to track the possession of real-world assets.

In each case, the cluster produces a record of events called the ledger. It will be preserved for the lifetime of the cluster.

As long as someone somewhere in the world maintains a copy of the ledger, the output of its programs (which may contain a record of who possesses what) will forever be reproducible, independent of the organization that launched it.

What are HCs?

A HC is the name of Huione Chain native token, which can be passed to nodes in a Huione Chain cluster in exchange for running an on-chain program or validating its output.The system may perform micropayments of fractional Huione Chains, which are called lamports.They are named in honor of Huione Chain's biggest technical influence, Leslie Lamport. A lamport has a value of 0.000000001 HC.

Disclaimer

All claims, content, designs, algorithms, estimates, roadmaps, specifications, and performance measurements described in this project are done with the author's best effort.

It is up to the reader to check and validate their accuracy and truthfulness.

Furthermore, nothing in this project constitutes a solicitation for investment.

PreviousLearnNextGetting started with Huione Chain

Last updated 7 months ago

Was this helpful?