Progress Report

Parity

Parity

What is Parity?

Parity Ethereum Client is software made by Parity Technologies

● Acts as a “full” node on the Ethereum network

● Keeps a synchronised block chain to audit other nodes

● Manages secret keys; signs and publishes transactions

● Written in Rust for correctness, performance and footprint

● Portable - works on Windows, Mac OS and Linux/Unix

● Modular actor-based architecture for reliability

Parity

What is Parity?

Advanced Ethereum client:

● State-trie pruning keeps database size to a minimum

● Auto-upgrading keeps node up to date via smart-contract

● Light-client operation for minimal-resource/embedded clients

● Chain-specification files for multi-chain interoperability

● Consensus-abstraction for pluggable consensus algorithms

Parity

PAR

● Fully syncs in around 60s● Serves & shares:

○ Compressed, condensed, aggregated state-trie data

○ Cryptographic manifests

● Multi-level security● Downloads receipts &

transactions to ensure full compatibility

Parity wire protocol for Warp-sync

Parity

PIP● Builds on Foundation’s LES

protocol● Request pipelining to

minimize round-trips● Responses fully provable:

sybil attack resistantParity light client Protocol

Parity

VaultsKeep your addresses to

yourself

● Geth-dialect of wallet files include address in plaintext

● Vaults encrypt address and other metadata of key files

● One path = one password● Enter path’s password to

see addresses of key files

Parity

Deep TracingFigure out what really

happened

● New trace_ API● Allows for:

○ state deltas○ VM trace○ deep transaction trace

● Used for:○ preview transactions○ re-run transactions

Parity

TendermintProof-of-Authority /

Proof-of-Stake pluggable consensus algorithm

● High-performance PBFT-based consensus algorithm

● Authorities controlled via smart-contract

● Proof-of-Stake variant

Parity

StratumSupport for Stratum

notification

● High-performance mining hardware can get TCP notifications of new work

Parity

Scheduled transactions

Transactions can be published only on certain

conditions

● Avoid publishing transactions until a specified:○ Block number○ Block timestamp

● “Alarm clock”● Scheduled transactions

persist between runs

Parity

Auto-updatingParity will stay in sync with

the network. Always.

● Multiple functions:○ Always○ Never○ Track versus minor-version○ Critical only○ Download only

● Controlled by smart-contract

● Smart-contract has partially-automated, multi-phase multi-key system

Parity

Parity Infrastructure

Smart contracts and services

● Registry hierarchical name registry

● TokenReg, DappReg, BadgeReg network-maintained indexes

● GithubHint/URLHint hash to URL hint system

● Operations Client version & consensus algorithm database/DAO

● SMSVerification SMS-based identity verification system

● EmailVerification e-Mail-based identity verification system

Parity

OperationsThe right information to keep network operations

going.

● Multi-stakeholder smart contract

● Multi-client, multi-track, multi-release, multi-binary

● Tracks consensus protocol● Implements much of

“Yellow Paper council”● Forks require teams signoff● Chronicles which releases

support which forks

Parity

SMS-CertifierFirst tool to fight Sybil

● Centralised service :(● Accounts get certified that

they have unique phone associated

● Low cost (12 Finney)● No data released on chain● Only hash stored on server

Parity

Email-CertifierSend Ether to an e-mail

address

● Centralised service :(● Accounts get certified that

they correspond to an email address

● Free● Email hash placed on chain● ETH address resolvable

Parity

What is Parity Wallet?

Primary user interface for the Parity Ethereum client

● Account/identity management

● Wallet management

● Contract development, deployment, management

● Secure authorisation & signing

● Transaction tracing and node management

● (Decentralised) Application publishing and management

● Chrome Browser Extension support

Parity

Account & Identity Management

● Name display: local and Registry

● Name input: local, Registry and e-Mail certified

● Displays Ether and Standard Tokens via Token Registry

● Displays certifications via Badge Registry

● Bestow and filter by tags

● Standard recovery phrase key generator

Parity

Accounts management

Parity

Creating a new account

Parity

Vault management

Parity

Account page

Parity

Sending funds to an eMail address

Parity

Wallet Management

● Seamless multi-signature wallet support

● Similar to accounts: taggable, badges, tokens

● One-click transaction approval

● Efficient transaction history

● Coming-soon: Wallet support for approving DApp transactions

Parity

Wallet management

Parity

Contract Development/Deployment/Management

● Solidity editor and compiler

● Streamlined deployment

● Management interface for:○ viewing public properties

○ calling into contract

○ executing transactions

○ inspecting events from contracts

Parity

Contract editor

Parity

Deploying a contract with parameters

Parity

Managing a contract

Parity

Executing a contract transaction

Parity

Secure Approval/Signing

● Multi-layer security approach:○ Only isolated high-security Parity module for storing/using secrets

○ Only high-security API allows signing to be approved by supplying password

○ Only JS signer code served by Parity has access by default

● In-Application overlay (“Signer Snippet”)○ Secure background pattern to ensure DApp isn’t sniffing password

○ Allows primary/default account selection

○ Identifies Application responsible for request

○ Works on Parity-hosted “DApplications” and Ethereum-enabled websites

○ Allows tweaking of parameters (gas, gasPrice and conditional publishing)

Parity

Signer with pending transaction

Parity

Tweaking transaction parameters

Parity

Application Publication & Management

● DApp manifest allows for metadata display

● (Decentralised) Applications visible on main Applications page

● Three sections:○ Local (those found in your parity/dapps directory)

○ Built-in (those that come bundled with Parity Wallet)

○ Network (those found published to the DApps Registry)

● Parity hosts all allowing for ease of development

● Coming soon: DApp permissions to allow certain DApps to access

greater portion of the API

Parity

Applications management

Parity

Node management & Transaction tracing

● View node information (consensus/chain/logging)

● Alter node operation (syncing & network)

● Published transactions can be traced

● View transaction queue to see nodes to which propagated

● May be resubmitted with altered gas/gasPrice

Parity

Viewing the transaction queue

Parity

Parity Dapp Tooling

Helping you build dapps

● RPC documentation auto-generated from the code with examples

● parity.js our low-level Promise-based alternative to web3.js

● oo7-parity.js our high-level Bond-based Dapp API

● oo7-react.js our high-level Bond & React-based helper API

● React component library for Dapp building blocks

● Tutorial available on Parity wiki

Parity

RPC DocsAutogenerated RPC

documentation

● All Parity RPCs now have markdown documentation auto-generated from code

Parity

parity.jsPromise-based Ethereum

Javascript API

Simple, async & compatible

api.eth.blockNumber()

.then(api.eth.getBlockByNumber)

.then(x => x.author)

.then(api.eth.getBalance)

.then(console.log)

Parity

oo7-parity.jsAdvanced Bond-based

Ethereum Javascript API

Succinct, Async and Reactive

bonds.balance(

bonds.blocks(

bonds.blockNumber

).author

).tie(console.log)

Bond = Ongoing Promise

Parity

oo7-react.jsBond-based React/Ethereum

Javascript API

render() {

return (<Rspan>{

Bonds.balance(

Bonds.block.author

).map(formatBalance)

}</Rspan>);

}

Parity

Works well with contracts

class App extends React.Component {constructor() {

super();this.coin = bonds.makeContract(

api.abi.erc20token, bonds.registry.getAddress(‘gavcoin’, ‘A’)

);}render() {

return (<div>You have <Rspan>{this.coin.balanceOf(bonds.accounts[0])

}</Rspan> GAV and <Rspan>{bonds.balance(bonds.accounts[0])

.map(formatBalance)}</Rspan>.</div>);

}}

● Fully reactive● Easy to extend● Composable● Simple API● Promise-friendly

Parity

Create new Bonded React Components

class Account extends ReactiveComponent {constructor() { super([‘address’]); }render() {

return (<span>{self.state.address}(<Balance value={

bonds.balance(self.state.address)}/>)

</span>);}

}class Balance extends ReactiveComponent {

constructor() { super([‘value’]); }render() {

return (<span>{formatBalance(self.state.value)

}</span>);}

}

● Fully reactive● Easy to extend● Composable● Simple API● Promise-friendly

What is Polkadot?

What does it provide?

Pooled securityall constituent chains of our community guaranteed

Trust-free transactionsconstituent chains can send transactions to each other

Entirely generalfree-form messages: no set semantics; same guarantees

as contract-calling in ethereum

How does it work?

Relay-chainthe top-level which coordinates consensus and

transaction delivery between constituents

Parachainsconstituent chains which gather and process

transactions

Basics of the Relay-chain

No functionalityno external transactions, no smart contracts

Governance built-intoken ownership gives voting privileges

Polkadot’s Relay-chain ensures that transactions between the constituent parachains get delivered and that they are all operating correctly.

Parachains can take any form of globally-coherent consensus system; potentially even another relay-chain. Enterprise-friendly encrypted, private, proof-of-authority chains are supported.

Bridges can exist to ferry transactions between the relay chain and existing, independent chains like Ethereum.

Extensible, Scalable and Flexible

Open parachains can be tightly integrated into Polkadot, using Polkadot’s validators to ensure their correct operation. They are the easiest and cheapest form of integration.

Closed parachains can be weakly integrated into Polkadot, giving them the freedom to manage validation internally e.g. using a set of recognised authorities.

Bridged chains can be integrated into Polkadot too. Bridges add complexity and cost to integration, but allow the chain to exercise its own means of consensus.

Polkadot network

Consortium parachain

Authorities manage parachain validation, access controls &c.

Transactions andinter-chain consensus

PolkadotJoin the dots

@gavofyork @polkadotproject @polkadotnetworkgithub.com/polkadot-io gitter.im/polkadot-io/Lobby