# Parity's Innovations -  Arkadiy Paronyan

- Channel: [Devcon](https://streameth.org/devcon)
- Date: 2017-10-09
- Duration: 12:38
- Topics: blockchain, smart contracts, distributed ledger
- Watch: https://streameth.org/watch/yt-xcajGEmC20A
- YouTube: https://www.youtube.com/watch?v=xcajGEmC20A

## Description

Visit the https://archive.devcon.org/ to gain access to the entire library of Devcon talks with the ease of filtering, playlists, personalized suggestions, decentralized access on IPFS and more.
https://archive.devcon.org/archive/watch/2/paritys-innovations

Ethcore is proud to bring you Parity, a high-performance implementation of the Ethereum client written in Rust. Ethcore will talking about what makes Parity unique for DApp and blockchain developers. Get a brief overview of Parity’s performance and security aspects. You will learn about some of the advanced features, such as state-tree pruning, blockchain snapshotting and transaction tracing. We will also touch on private chain’s use of Parity and present a roadmap for the features to come.

Speaker(s): Arkadiy Paronyan
Skill level: Advanced
Track: Developer Infrastructure
Keywords: client, node, mining, api, rust, library, api, latency, dapp, security, rpc, keys, pruning, tracing, sync, poa

Follow us: https://twitter.com/efdevcon, https://twitter.com/ethereum
Learn more about devcon: https://www.devcon.org/
Learn more about ethereum: https://ethereum.org/ 

Devcon is the Ethereum conference for developers, researchers, thinkers, and makers. 
Devcon 2 was held in Shanghai, China on Sep 19 - 21, 2016.
Devcon is organized and presented by the Ethereum Foundation, with the support of our sponsors. To find out more, please visit https://ethereum.foundation/

## Transcript

hello I'm on one of the court developers behind parity and today I'm going to speak about what we have been working on the past few months and what we have in store to come so parities you know is it fully featured if your own client has everything you need to run a full no ordinary theorem network can sync the blockchain it can do mining it has the API compatible with other implementations but it is also so much more so yesterday we've seen what the user experience might look like with parity and it will look like that soon and today I'm going to focus on technical features that are would be interesting for tap developers or watching developers in general so parity is written in rust rust is the relatively new programming language out there which is particularly well suited for system programming and building fast and reliable software it has memory safety and concurrency safety guarantees know that without sacrificing performance and it works very well for whatching applications where reliability and speed are equally important and it worked very well for us or Tim was quite happy with this choice and yeah we saved us a lot of time so for all the developers out there I would greatly recommend to take a look into it and it's also one of the reasons that we believe parity is the fastest a theorem point out there but more on that later and from day one we designed parity to be modular and configurable so you can use it as a library we have what we documented internal api's then there is a ton of command line options to tweak various as aspects of paratus behavior and soon we'll be providing configuration file so that you could easily manage all these options and then presets so that you would have a particular set of configurations optimized for usage scenarios such as mining or Runyon and the Raspberry Pi or during that development now let's get to performance a bit I'm gonna show you just one figure here 20 1910 sections per second you know that's how fast parity can handle sink in the bottom that's the main homestead watching first 2.2 million box with nine and a half million transactions in them and that includes full work and transaction validation and that's how fast is the that's the average transaction rate at parity can do and there is still room for improvement and we're still working on optimizing this even further now we also take a great deal of effort into optimizing latencies to work and transaction import times when the new box arrives from the network it gets imported and propagated in the least possible time and all of that comes without using too much memory so that you can easily run parity on a second generation Raspberry Pi and it won't break a sweat and you can even use it as a DEP server now let's talk a bit more about security probably heard all kinds of security issues with a few memory recently so one example is if you expose your RPC to the external Network and you unlock your account even for a short duration you will probably get your phone stolen and nowadays most of the clients work around that by duplicating unsafe api's and we took it one step further by introducing the secure transaction signer architecture the idea is that all the api's that work with private keys such as send in a transaction and they become privileged and they no longer execute immediately instead when I DEP sends a transaction it is added to the confirmation queue and it stays in the queue until user confirms or rejected and that confirmation is done over an additional secure channel that is not exposed to the external Network and it is isolated from the abscess run runs in the sandbox isolated environment and it also requires additional authorization which comes in the form of the observation token which usually needs to enter first time before using it and yeah I can show you the UI for that so that's a bit outdated version but still so there's a UI for confirming transactions so this is a version which is the Chrome extension so when it's absence it's transaction and I can pops up and there is the list of transaction to confirm and you can do that informations action now we have further plans to I saw is even further to move it to a separate process or even to a different machine the one with the key store so it can be secured and would communicate with a node over a secure IPC channel again there's a lot more features parity start with state tree pruning this is something that can greatly reduce watching database size so it works by discarding the all watching States so that the state is preserved only for the last thousand walks and the rest is discarded this means you won't be able to say query parents that account had thousand Watts ago but not that many users or applications needed information anyway so it is discarded by default and that saves a lot of disk space no the database I'm size for the way the swamps that network is under five gigabytes that feature turned on but if you need for both data you can still have that there is an option to keep it transaction Jason that's the API that we've introduced recently it's an extension and it allows you to query extended transaction information for example you can pick an account or a set of accounts and you can query transfers involving these accounts or what the hell watching and this will include transversed originating from smart contracts something which is very hard to do using the standard RPC and if you run this query over the whole work chain it will still work fast because we use a lot of optimizations to make them work past this small to have a boom filters and so on and this is something can be useful for writing something like an action Explorer or for any adept it needs extended transaction history okay it's an app shot in this is something simple basically you can save state of your watch into a file that file contains all the state information of the recent state information and a few thousand of the recent Watts and it is heavily compressed so that the current snapshot for the way this homestead is under 150 megabytes and then restoring from the snapshot takes only a couple of minutes yeah use run restore command and in two or three minutes you're good to go now as I mentioned it doesn't contain all the blocks at first you end up with some of the blocks missing the older blocks but as soon as the node starts working let's sink to ready state it will download of the missing box in the background so you end up with the whole watching after a while so this doesn't compromise the network security now we'll be taking this even further soon by introducing the snapshot sync or as we call the work think the idea is that every node well every parity note for now on the network will take a periodic snapshot every eight ten thousand walks and that snapshot is the same across all nodes and the nodes that start syncing and download these snapshots from other peers and sync from them so yeah basically you start from stretch and in two or three minutes on a fast Network you you can start working with the theorem doing transactions and all that okay private chains private chains are extremely easy with parity all you need is one files it's a JSON file that lists all the private chained specification we have a few examples basically it contains of it all you need so theorem protocol parameters such as the target walk time Genesis board data network parameters such as network ID or a list of good nodes you can even replace proof of work with proof of authority which is basically a list of notes that are allowed to produce walks without doing any mining and something which is not here but which something that we'll be adding soon is the ability to include building contracts written in native languages such as C suppose first for rust basically you just declare a dynamic library and an entry point into that paraty we'll call it when it's time to have a smart contract so there are a lot of more smaller features but I'm gonna focus know what's about to come so the private proof of a forest change that have mentioned earlier they're quite basic at the moment we want to improve them by making them Byzantine fault tolerant so that you can have a full-blown industrial grade permission box in solution build on top of that stratum protocol something requested by our a miner's community also coming soon this is the product code to push what work notifications to minor over TCP wide find so initial work has started on that and it is coming out eventually and of course metropolis transition as soon as this specification is ready we'll start working on it and be sure to release it as soon as possible yeah this is para team we encourage you to go check it out check out our wiki if there's features that you might be missing in other clients and if you have any questions join our discussion and guiter will be happy to answer them all yeah thank you thank you very much agony