IZZZIO
IZZZIO, izzz.io — open-source customizable blockchain framework, with turing-complete smart contracts. The platform provides the ability to modular network configuration with by a replacing functional blocks, different consensus options, customization of block time and size. Platform based on LCPoA. Also supports other consensus mechanisms..
Contents
Platform usage
The platform is used by several companies as a blockchain base:
Architecture
The platform is written in the language and based on .
Blockchain
The blockchain is organized according to the principle 1 transaction per block. JSON is used as the data structure of the blocks. To store blocks data used LevelDB DB.
Block structure:
- Hash of the current block
- Hash of the previous block
- Index number of the block
- Start time of block generation (for LCPoA)
- Block end generation time or timestamp
- Block data as a JSON object
Using JSON as a block structure allows you to use structured data of arbitrary size directly into a blocks.
Smart-contracts
Smart contracts are provided by the EcmaContracts module. The contract is written using JavaScript ES6. All contracts run in an isolated virtual machine, with isolation from access to the system and to other contracts. During synchronization, each node sequentially repeats all actions with contracts from the blocks, and saves the changed states locally. As a result, the local states on each node are fully synchronized, which allows the code to be executed decentralized and reliable, and ensures that the result of the work is determined.
The principles of writing contracts are similar to Ethereum, but EcmaContracts already has a minimal implementation of a token standard similar to ERC20 and BigNumber library for safe number handling.
To run the contract used Isolated VM based on the JavaScript V8 engine. Each isolated environment has a limited amount of resources (CPU time, RAM, number of calls) and limited internal functionality:
- Contracts cannot use system methods, or runtime methods directly
- Saving state between launches can be performed only using the built-in data types: KeyValue and its derivatives BlockchainArraySafe, BlockchainArray, TokenRegister, BlockchainMap
- Contracts are not available methods of asynchronous code execution, Promise, setTimeout, setInterval, nextTick
- Contract code works completely synchronously
- Exceeding the allowed resources instantly terminates the execution of a contract with an error
- Methods of working with dates replaced. The current date is the current block time
- The method of working with random numbers is replaced. The generation of random numbers depends on the current state of the contract
- Constructor of contract class is not available. Use init and deploy methods instead of the constructor
- All contracts must be inherited from the Contract class or its derivatives
Internal additional functionality:
- Built-in BigNumber type for safe work with large numbers
- TokensRegister class that implements token functional (coins)
- Contract TokenContract implements the functionality of the token (coin)
- ContractConnector class to interact with other contracts in the system
- TokenContractConnector class for interacting with other contracts in the system that inherit from ContractConnector
- SellerContractConnector class for interacting with sales contracts
- Require – an alternative way to interact with other contracts in the system
- BlockchainArray – a data type similar to an array (Array), using a KeyValue object to store data between runs
- BlockchainMap – a data type that implements the Map view, using a KeyValue object to store data between runs
- TypedKeyValue is an analogue of KeyValue, preserving the original types of values
- Event – class for generating events
- assert is a built-in class that allows you to perform critical item checks.
Master contracts
The master contract is the smart contract of the EcmaContracts system, which is responsible for the allocation of resources (CPU time, RAM, call limits per minute) to other contracts, implements the functionality of the token embedded in the system, and also manages the system of mutual settlements between other contracts (Buyer-Seller contracts).
Cryptography
Due to its modularity, the system supports various implementations of cryptographic functions:
- Basic crypto iz3-basic-crypto provides basic cryptography (SHA256 hash, RSA sign with 2048 bit key)
- iz3-bitcore-crypto module bsed on bitcore cryptography (like Bitcoin or Litecoin)
- GOSTModules module open-source implementation of russian GOST cryptography (GOST R 34.10-2012, GOST R 34.11-2012 (Streebog))
- cryptoPRO module provides certified russion GOST crypto based on CrpytoPro CSP 4.0 provider (GOST R 34.10-2012, GOST R 34.11-2012 (Streebog))
StarWave messaging protocol
StarWave – internal subsystem of message transmission in the network consisting of IZZZIO nodes, not connected with a blockchain. The StarWave protocol allows you to transfer data from one node to another without making a direct connection between the nodes.
Internal address is created for each node consisting of a random sequence of alphabet characters and numbers. These addresses are used to automatically routes messages transmitted using the StarWave protocol.
Each node of the network stores information about the addresses of connected nodes, which allows you to make a route map required for quick message transfer (routes).
When first message sended from one node to another, the message is sent(broadcasts) to all available nodes. When the message reaches the reciver, the route of the message is saved as route map. All subsequent messages are transmitted with route map which allows sending them with minimal delays.
In case of a route violation and the inaccessibility of nodes from the route map, the route map is rebuilt from the last available node, which allows transmitting messages even if the topology of the network is often changing.
Messages are not transmitted if the message lifetime has exceeded the specified threshold or the threshold from the configuration file.
StarWaveCrypto
StarWave protocol extension plugin. StarWaveCrypto implements the secp256k1 encryption key exchange using Diffie-Hellman (DH) protocol. Subsequent data exchange between nodes will use an encrypted channel.