Building Effective Trustless Networks on Ethereum

Transcript

only way the best way to risk no municipalities okay you all right

thanks for bearing with the technical difficulties my name is Chaddock strange I'm VP of product at scale labs I'm presenting on how to build effective trustless networks on aetherium let me just ask who here has heard of scale network ok cool awesome great so I wanted to conceptualize this interview as or this presentation as we have this we have a challenge here let's say that we need to build an effective lair to proof of stake network to skill aetherium and it has to be 100% compatible coupled with aetherium

because how can you use a scaling solution if you're using the theorem and need to learn an entire other technology ecosystem so there must be that tight coupling this network must be self-regulating and self-reinforcing to be decentralized all the actors need to sort of check one another and all the scaling resources must be commoditized in an efficient way on a market such that any dap developer or someone who needs a scaling technology can do so at any given time with efficient prices and get those resources from the network easily and the network agents may be Byzantine at any given time meaning these agents might go down they might be

an active or they might refuse to communicate with a network so any sort of Byzantine type of behavior on the network and the entire network set up must be trustless and decentralized so this is quite a tall order for a design and technical specification and this is exactly what skill network does and this all does from a particular way of how we architected the network and in talking to a lot of people about scale network I've seen a lot of confusion about this and I wanted to create this presentation to sort of guide people through this sort of nuance but really important part of how our network is structured

and that has to deal with the skill manager system the skill manager system is a set of aetherium smart contracts that is designed and is deployed onto the etherium network and this scale manager the set of contracts it actually orchestrates all the business all the functional logic to empower this layer to proof of stake network so it lives on aetherium it's tightly coupled with aetherium uses all the great security mechanisms of aetherium being decentralized and a proof-of-work layer layer one mechanism and this contract basically orchestrates all these nodes all these hexagonal nodes of computing

power that is providing this power to this layer two proof of stake network and because it's built on etherium using solidity contracts it's compatible with etherium it's compatible with etherium when you deploy onto a scale chain it's also compatible with the theorem in that the entire business is compatible with aetherium and it's tightly coupled to the etherium network because we don't want people to know that there aren't a completely other network to get scaling technology it must be tightly coupled so that you don't even know that you're using an entire other network to scale your decentralized applications and part of how we provide the compiler the power to the network is through a function of

the scale manager system that deals with validator and delegator flows skill network is a proof of stake network so any agent or any any business can come and create a validator business onto the network and then it's register nodes on to the scale manager which they're communicating with the contract on aetherium and accept delegation and staking and and all these flows are defined and functions in the scale manager contract such that the etherium main net is used as an anchor point to orchestrate the registration of validator nodes to orchestrate the delegation of delegates in to the network into the scale network of

validators and to provide resource is from these computing resources that validators are providing on the right here I have an example this sort of rectangular box as a representation of a single validator node so a node can a validator can register onto the network they can accept delegation up to a minimum staking requirement and this allows them to operate a node on the scale network and this is all again done through interacting with a scale manager contract on aetherium and a validator can have any number of nodes so long as those delegations that he or she receives meets the minimum mistaken

requirement cumulatively across all the nodes this function is also done in the scale manager system such that it's pretty it's a pretty simple flow you register as a validator you register the number of nodes you accept delegations up to the MS our requirement for the number of notes that you have and then those notes become registered with the scale manager become operative on the scale network there are some other proof of stake network systems where the payment of bounty payments is put on the onus of a validator to handle for the scale manager system we've actually coded that in as a calculative operation that all the bounty payments are also done on

chain in a transparent manner such that if you're a delegator at the end of every epoch your rewards that the validator and the delegate errs earn or automatically divvied out to all the validators and delegate errs and then all the slashing conditions are also orchestrated by the scale manager system to keep people compliant and complete them incentivize them for good behavior and again all the slashing is done through on chain contracts and so all of that process is transparent another part of the network given that you have validator nodes that are operating yet many agents or many validators operating these validator nodes how do we make

sure all these validator nodes are operating well they're operating very performant and these validators are operating them with good infrastructure we need to have a monitoring mechanism for every single validator node in the network to then monitor or self-police every other node in the network and that could be across other validators or or whatnot so we created this concept again in scale manager where every node is monitoring every other node the act the network is actively self-monitoring self-reinforcing so over the given epoch of a certain month of operation for all these validator nodes to exist on the network every single node is monitoring 24 other nodes and reporting that

information to the scale manager system on aetherium and so what this looks like is when you register a validator node on the network you're interacting with a scale manager system scale manager generates a random group of 24 nodes that you your node is responsible for monitoring and your node will automatically find those groups and then start measuring automatically over the given month and reporting statistics of like uptime the performance and reporting that to the scale manager as a verdict at the end of the epoch and this verdict is used to help ensure that bounty payments are accurate so at the

end of month if you're a performant node the majority the network is a Performa node all network operators will earn their out their optimal bounty if you're a node that tends to be offline like half the time or have very before unperformed metrics and you're way outside the tolerance interval or out an outlier you might be paid a little bit less than your optimal bounty payment for the month so again this system is all recorded on to the skill manager system on aetherium the other thing about the network so we've talked about validator nodes and how they can provide resources to the network we've talked about how all these nodes will monitor

every other node of the network a scale manager system also monitors the resourcing of scale chains that come out of these validator nodes that are provided for deaf developers to scale their applications and so this resourcing we've created an efficient market for scalable resources that's actively monitored and allocated out by the scale manager system so we have this commoditization of resources and a market for scaling and how this is done OUP's is every the scale manager tracks the resourcing available in every single node and so if a fraction of the node

resource is given for a scale chain the scale miniature system checks that to understand the health or whether the network is at capacity and then regulates whether to incentivize more validators to create more nodes to then balance the supply and demand of the network when a note when a scale chain is created a group of random nodes is selected by the scale manager to provide resourcing for that particular scale chain as well the scale manager also you can think of these hexagonal Zoar circles as each scale chain and so these are individual nodes that participate in a scale chain and over time scale manager swaps these nodes out at random

the reason for this is a single scale chain could operate a smaller DAP it could operate a huge DAP like say a decentralized exchange with quite a bit of assets on top of it over time you could actually have a collusive behavior where you can learn all the other nodes of your network that's also operating that decentralized exchange to prevent collusion we swap row notes randomly out of the scale chain and swap a node in and so there's this node rotation procedure that is seamless for the DAP developer you don't really know that that node rotation is happening but again that's all done by the scale manager system to prevent collusive behavior over time let me just ask before I get there so I'm a product guy

I'm not a mathematician I'm not a cryptographer but I want to ask what cool crypto algorithms does the audience know of or is aware of just curious okay new cipher okay well one of my favorite crypto algorithms that I got into in terms of product was the joint Fellman protocol the reason for this is our entire scale Network uses threshold cryptography and professional cryptography to work we use BLS professional signatures BLS special signatures is a really great technology the only difficulty in implementing BLS

special signatures is actually doing a ceremony called distributed key generation we use the joint Feldman protocol for distributed key generation and that's because this threshold crypto system using dkg and BLS special signatures becomes very powerful coupling for Byzantine fault tolerant state machines if you're operating a scale chain and a number of nodes are Byzantine how can you then facilitate signing blocks without having a threshold crypto system the threshold crypto system notes can be Byzantine they can be offline but up to a threshold can of nodes can continue to do signing operations with BLS threshold signatures and so scale manager system

also has this on on chain contracts we have elliptic curve diffie-hellman key exchange be LS threshold signature verification and distributed key generation contracts that are on our scale manager system that also facilitate network operations in the goal for this crypto system function is that every node or every node that participates in a scale chain should have its own private key and then all nodes that are on that skill chain combined should have a shared public key to sign blocks onto their blockchain nodes can be Byzantine they can be offline or refuse to communicate with the network but up to a threshold they

can still perform signing operations with this these threshold signatures and the signature is the same regardless of any combination of signers so you can have 12 signers their team signers the signature is still the same it's pretty magical for BLS threshold signatures to do that and this entire setup to create these private keys and public keys must be done without any trusted partner so the next couple slides I spent some time to try to conceptualize what this protocol is doing because I think it's pretty elegant so I kind of went crazy on animations and powerpoints so hopefully this won't work or hopefully this will work on the left which you don't see right now well you don't see it because of the

screen but there are 16s triangles here and each triangle has a key each of these keys right here are representing public keys from other nodes so what happens in dkg process to begin this every node is creating a disposable key and every node has its private key and so there's a loose there's a swap in or exchange so nodes will each one node will take its disposable key and take all the other public keys of all the other nodes and it will assign or encrypt or rather encrypt its own disposable key and so you would generate 240 of these

encrypted disposable keys using every other nodes private or public key and this information is sent over to scale manager system on aetherium to simplify the animations I cut down all 240 keys to basically let's say there's an encrypted encrypted key with the other 15 public keys what also happens is the notes and something called a verification vector to the scale manager system and now what happens is that the each node will download from the scale manager this verification vector from other nodes and the encrypted disposable key and every node will check every

other node to see what using the verification vector and this key of whether they match and if there's a match every other node is doing this overall iterating over all the keys the cryptic keys so they check and they match everything looks good the scale chain will send an alright message to the scale manager system and then what happens is a broadcast method or there is a broadcast of the summary of the verification vectors over to the scale chain system and this has done sixteen times and after this is all received after sixteen times each single node uses this information to then generate its own private key and the cumulative

final verification vector is the common public key so this allows every single node to sign a block up to a certain threshold now you might ask what happens if this process occurs and that there's an issue so maybe one no was trying to be malicious so they sent bad information so node sixteen at the bottom here picks out an incorrect match if the node system will then send a complaint to the scale manager system at this point the dkg process has failed and will begin to restart with a new group of nodes to create this skill chain but we still need to figure out whether that

complaint was valid or not so the next process is that node one must send its disposable key to the scale manager to prove whether they are in violation of this complaint so that sent to the scale manager there's a check that ensues and if the disposable key does not match that node then becomes slashed if the node refuses the spent to send its disposable key in a certain amount of time it is also slashed if that disposable key actually matches then the complainer will be at fault for submitting erroneous claim so what I've gone through are some key features of the scale manager system again we've

made it to be tightly coupled with the etherium network by deploying these contracts onto aetherium this is allowed us to basically orchestrate our entire network or layer to proof of stake network to help aetherium scale today and this allows validators and delegator x' to interact with a skill manager system to provide computing power to the network the network is self-regulating skilling resources are commoditized in an efficient way and all tracked by the skill manager system network agents may be Byzantine and this is all orchestrated in a trustless decentralized an open-source manner using scale manager system on aetherium you can check out our website at scale Network comm we also have our github

where all this code is open source so feel free to take a look at the technology and use it as you wish I'm Chadwick Strange I'll be happy to take any questions thank you and if we could take questions outside the room because we're obviously running a bit late so we have to move thank you