Alexander Skidanov on a new NEAR Sharding Design: NightShade

Captions as YouTube publishes them, usually machine-generated, so product and people names can be misheard.

1. 0:03

   hi everyone I'm Alex and let's talk about whale fishing let me quickly introduce myself so I'm one of the cofounders of mere protocol I was before near protocol I was working for a company called mem sequel it's a chartered database I was the first person to join them sequel back in the day back in 2011 when it was just three people and a pomeranian in the garage all right now it's a 150 people with a multi-millionaire or before months ago I worked for Microsoft and

2. 0:37

   the for Microsoft I was participating in programming competitions called ACM ICPC where like in 2008 I got a gold medal which will be relevant in a quick second and near protocol we started it last August and we started as a public chartered blockchain with the idea being that we looked at the space of all the layer on protocols which it there are many of them being built Definity Algar and space mesh etcetera very few of them were shorted and charging is sort of

3. 1:10

   important because if you think about I like using thunder as an example because Thunder is a pretty fast blockchain Thunder can be up to hundred times faster than the theorem but the thing is that if Thunder gets adoption and blockchain in general becomes more used the next thing we know is two years from now we're going to be building thunder replacement because we had capacity

4. 1:31

   again because now we hundred we consume a hundred times more and shortening doesn't have this problem shorting scales with adoption the more adoption you have the more people using it the more GPS you have and and as we started building sharding we realized that in reality building started blockchain today is very similar to building a huge stadium in the middle of the desert right so we can have multiple stadiums

5. 1:55

   being being deal there and one will have 100,000 seats another one will have 200,000 seats and the third one actually will scale with the number of people there but it will not matter at all and until we actually have people who want to watch a game right and so from this perspective we shifted the emphasis towards building a very usable blockchain right so our current mission is to build a blockchain such that developing for it is as simple as

6. 2:21

   building a node.js application and using it once because once an application is deployed should be as simple as opening a website and initially I wanted to talk about usability but I changed my the topic of my talk to sharding and for charging I don't have a demo but it wouldn't be a demo night if I didn't have a demo at all so I will quickly show you our development experience just

7. 2:44

   just like if any of you built on a theorem I just want to show you the how different could development experience be and if you want to try it yourself the website is near dev that's where we're hosting our development experience it's on landline ID which is a for cover ID called assembly script and oops and as you Lu launch it the first thing you will see it will suggest you to clone to fork one of the

8. 3:15

   existing examples and for this for this demo I will use a guestbook example which is a toy example and blockchain and when you create it it will be populated with the let's code and so on the left you will see all the types which files is the smart contract so the the language near near law runs wasn't on the back end and so typescript is one of the languages which can compile two of them and that's the linkage we

9. 3:39

   promote because any person who knows JavaScript can right away start booting on wasum and and so effectively the code I'm not going to go through it too much right now but the code is very close to what you would have if you built it in node and the beauty of it is that once you finished writing code if you actually want to first of all you can write tests in Jasmine which is a standard JavaScript framework and if you want to test it in one click you can deploy it to a to a test net and it will

10. 4:11

    run all the tests and to give you the results which hopefully it will pass and it passes right so you can you can iterate very quickly you change your smart contract in one click it gets deployed to an actual blockchain and run and similarly if you want to run it and and and and play with it or share it with someone again it's a single click in one click you deploy it to the test

11. 4:32

    net and you can start using it without having any any browser plugins you don't need to to understand what the private key is etc you're just using it right and so that's a guestbook I can post something and it shows up and if you want to test it with multiple users you just give them the link and they can open the same link I guess you don't see it doesn't help much ok you can give them the assembly the same link and they will be able to interact with it

12. 5:06

    themselves as well using their own users and so you can actually test Multi multi user deployment and a particular beauty of it is if something doesn't work right so let's say my smart contract doesn't work and I don't know why it is what they can do is I can in the smart contracts on the back end I can look something and I redeploy in one click again and so now as a login if I open up your Vela /

13. 5:54

    tools which I hope they will be big and I post something you will see this one that they logged is logged in my browser consult on the front-end and so now something doesn't work in a smart contract at the very least what I can do is I can near that log after every line and they can bisect which is actually going wrong right it would be even better if it was integrated into this debugger which is the next step it's not built yet but this is something that is

14. 6:27

    possible because wasn't is actually something that a browser can run oh yeah so that's a sneak peek at the development experience now let's talk about charting so first of all why why I think that near is the team to build charting it's because it's one of the very few teams that actually comes from the industry we have multiple people from REM cycles it besides me we have also Misha who is a who's particularly famous for being one of the nine twice a

15. 6:58

    CPC champions in the world and she was one of the six happened to two weeks ago and we have lots of very experienced people coming from Google and besides me and me we have one more I CPC gold medalist so it's a it's a very strong team coming from from the industry and not from academia and and historically it happens that majority of production systems are built by by people from industry ok so let's talk about charting let's say we have a blockchain without

16. 7:29

    loss of generality it could be a theorem it could be a Bitcoin and it's low so let's say can process let me kind doesn't okay so let's say it can process twelve transactions per second or seven transactions per second and that's not enough let's say we want more let's say 156 transactions per second what can we do there's actually a very simple solution for 136 transactions per second what we do is we run three blockchains

17. 7:54

    and that's it scalability solved there are however two problems with it one is if they don't communicate that it's not the same as having one blockchain probably if you if you're running something on the blockchain and someone else is running something the blockchain you want those things to communicate at the very least you want to be able to pay anyone else on the blockchain

18. 8:16

    right and and the second problem which is a way bigger problem is that you can run one blockchain securely but it is not necessarily the case that they can run multiple block chains securely as we all know historically with it you see being a good example once you have multiple blockchain sharing the same security model but not sharing security they become vulnerable right and the idea is if you have one

19. 8:41

    blockchain you need to corrupt 50 percent of every person who maintains it whether it's 50 percent of stake in a proof of stake or 50 percent of hash power but if you have multiple block chains to corrupt at least one of them you need 50 percent divided by the number of block chains to corrupt at least one right and unless you have cross heart communication the remaining block chains might might not care much so for example the theorem doesn't care much about it a failing classic being corrupted but once your chain start communicating that becomes a

20. 9:13

    big problem imagine someone actually made some cross cross chain transaction from eg C to e th and then if you see what reworked suddenly there's something on the key H which is not backed by something locked on it you see that's a huge problem right and so this is a solution to this problem which says let's not allow people to choose what they validation right let's not allow people to assign hash power to a specific block chain or

21. 9:37

    specific chart or let's not allow people to assign theirs take to a particular shirt and let's sample the trendabl instead right so if you have a pool of let's say 1,000 people who are willing to be validators we're not going to allow them to distribute themselves between shirts we're going to say every person will be assigned randomly to one of the shirts so at this point if you control let's say you control one tenth of all the validators there is no way

22. 10:02

    for you to assign all the 10% of them to the same shirt and so you cannot really corrupt the shirt in reality what will happen is that will control 10 percent of validators in every shirt which does not help you in any way and and that works if we're assuming that so you thirty percent here as as an example for any sort of DFT consensus but let's say if you use some sort of proof of proof of work or and in the comodo consensus and you're willing not to have longer

23. 10:27

    finality you can use 50 percent here but as long as less than that threshold is not corruptible that works why does it work well let's see let's say that you are a user of the system so you are there on the far left and you want to know what is the last block of the system and so what you do is you go to the validators who are validating the blockchain today and you're asking them what is the last block and the moment you see two thirds plus one of them saying this is the last block because you know that 70% of them

24. 10:53

    are honest you understand that in that in the signature just received more than one third was honest and so that has got to be the correct block right and what did they learn about the the the the previous block on top of which they built the block well they did the same thing right they asked the validator from the previous block and at that point seventy percent of validators were almost right and where did they learn

25. 11:15

    about the block they asked the previous guys and by induction we go all the way back to the Genesis block which by definition is correct and so you can actually be absolutely certain the blockchain is correct just by seeing an attestation from the current validators on the latest block that's beautiful this is one problem which is you cannot assume that 70% of people are not corruptable if you actually think why people validate block change they only have one

26. 11:39

    motivation to do that it's money right every single person who minds Bitcoin the only reason they do that it's not some sort of gift to the society of securing Bitcoin right they want bitcoins that they will get one day when they mined a block and if you think about any proposed state system also one of the biggest motivations for people to validate is to get the reward right and so clearly they are corruptible by

27. 12:04

    definition they want they want money at the very least you definitely cannot assume that seventy percent are not corruptible and so we're changing our assumption now our assumption is less than thirty percent of all the data's are malicious and the remaining 70% are reasonable meaning that they will do what we want them to do for as long as it's in their interest but the moment they actually will they have a better option they will do the better option

28. 12:27

    right well that creates a problem which is if we have 1,000 short and the malicious actor has some interest in corrupting one of them they can in some way identify the validators who are presently assigned to the chart they can go to them and they can offer them more money and they would lose if they misbehave so for example in aetherium today in the theorem design today for a theorem serenity STM 2.0 this take is 32 Eve and every shark has 100 validators so you

29. 12:58

    would go to a shirt and you will corrupt 3200 if that's going to be your cost of corruption plus epsilon because they need to get more than what they spent which is going to be way cheaper than a single then corrupting the entire system what can go wrong if you if you corrupt the shirt so let's see actually successfully corrupted the shirt and you have Byzantine majority in a short technically you can do your work you can

30. 13:22

    fork but every every sharted blockchain today has a protection against it it is called shared security where you're producing blocks and shards independently but is one very secure chain so let's say let's it is actually stupid stealing 1.0 running and whenever you produce a short block you snapshot it to the etherium and once it is only a theorem it's irreversible right so this way in order to reward any search and

31. 13:47

    you have to your Kathy Rome which is very expensive but if I cropped it a short they will not do rework what they will actually do is I will create a completely invalid block right on this example the block B is some block where the state transition is just applied incorrectly so let's say before the block LS had one token and Bobcat 0 and after the block Ellis has 0 and Bob has 1 million and there was no transaction

32. 14:10

    applied right when so naturally any honest note which is monitoring short one will immediately just reject the block has straight up and correct but that's but if we have 1,000 shirts it is presumed that nobody is actually validating all the shirts and so in particular validators of char - might as well not validate every block of third one they might just not have capacity to validate every block of every shirt

33. 14:34

    right and so the only way for them to know that the block is valid is as we discussed previously they will look at the at the station from 2/3 of validators right and so they look at that the station from 2/3 of validation block see there is an attestation so they presume that the block is correct and they accept the krauser transaction which sends 1 billion tokens from the shard 1 2 - char - and now sure - which is completely valid that at no point it

34. 14:58

    was corrupted suddenly has tokens which never existed right and and so one solution would be for sure to to actually validate the entire chart one chain but imagine it is 1,000 charts and all of them sending transactions tool to all others it becomes completely infeasible for every validator to validate every other shirt there's a solution again and a solution called the fisherman with the idea being in there's at least one owners validate right so we're not talking about one

35. 15:23

    third or 50% if there's at least one honest that one known as validator will obviously notice that the Block B is incorrect and so what they do is they fishing they they going to short too and they saying you see how this cross card transaction coming from chart one but here's the thing the block is invalid and here is a very small cryptographic prove that it is invalid and what happens is in reality fishermen will not

36. 15:45

    fish to shore to it they will actually fish to that very secure global chain and the global chain will just slice all the validate this one short one and will undo all the damage they have done the problem is that imagine our previous assumption that every short has my honest majority right and they never corrupted then the moment we see that the station and block see we can immediately process the second part of the transaction rights imagine this transaction that the crucial transaction that goes from Block C to block Y is

37. 16:19

    something that spends Alice's money on block she in in short one and adds money on to Bob on shark on shark - without fisherman we would just immediately process it right would we would the moment the Block C is produced and this cross card transaction reaches the second shirt they will see this transaction they will set the station on the block they will immediately apply it and in the second block and so cross our transaction the time it takes for cross our transaction will be just one block

38. 16:44

    which is let's say six seconds right now with the fisherman this delay actually needs to be very long because that one is validator they need to realize that the block the invalid block was produced than you identified and loaded verified which takes time actually prepare prove that it is incorrect send it ensure that it was actually received on the other side right it will take a lot of them so how do we solve it well the easiest

39. 17:09

    solution is to say that sure to actually will not execute the second part of the transaction until certain sufficiently long period passed after which they sufficiently certain that no teaching attempt will be will be made that's a disastrous approach because your crush our transaction is now easily ours the second approach which is slightly more reasonable is to say that imagine and chart1 at some point a block was created which was invalid so the very first red block in short one is

40. 17:38

    invalid and then few more blocks were produced on top of that nobody noticed and then in the block in which it says a one that's a initiation with krushworth transaction which reaches the second shirt and on the second short that is immediately applied so immediately at the receive a to the immediately applied but then a phishing attempt happens if if a fisherman at some point actually says oh you know what short one was an

41. 18:03

    had an invalid what what happens is short one Forks out naturally because because the the chain is invalid but also start to will also fork out effectively what we're saying is that if you applied a transaction which re generated from an invalid block your block is also invalid right and so a phishing attempt happens all the affected shorts fork out and so now you're the crucial transaction time is actually very low and the finality like

42. 18:29

    let's say let's say you some sort of an exchange and and you actually happen to verify both short one and short - then then your finality is instantaneous because if you know the third one is valid and you know the char - is valid th you don't need to wait for phishing attempts because you know there's not going to be a phishing attempt right and from here we can just a completely different model to think about it but at

43. 18:51

    that point you can start thinking about it as not multiple chains multiple search ends you can think of it as a single chain with huge blocks where nobody actually sees the content of the entire block everybody on the app your support of the block right and then and then and then the same thing applies right so this is a huge block in the in the global chain we're insured once something in valid was applied sure -

44. 19:14

    still valid up until now then another huge block produced and the crucial transaction happens here now both of them are valid at some point fisherman fishes and you can think of it as just this global chain working out instead of think thinking of it as multiple search ants working out cool so now let's quickly talk about how fishermen would actually prove that the turns that the block isn't valid tried

45. 19:37

    because short - no validator in short - actually has the state of short one right that's it it is it is completely infeasible like today a theorem state is 100 gigabytes at 12 transactions per second right it is unclear if the if the relationship between the GPS and state growth is linear but it is probably close to linear that means that if you have thousand transactions per second you will get to 100 gigabytes state within days right and so it is

46. 20:02

    infeasible for everyone to have the full state everyone everyone has just the state of the shirt so the char - has on the state of the shirt to charge one has the state of short one so by the time one fisherman sends the fishing attempt they need to prove the shirt to that block B is invalid without shirt to actually having to download the state of the short one so how would you prove to someone that block in a film is invalid

47. 20:24

    without them having the state because the only thing that what contains is the transactions right so what you do is use this construction called Merkel T and I Merkel T so this is the whole state of the entire system or like all the chard and what you do is you compute the the hash so every so in the very bottom you have the actual state and on every level above you have a hash that hashes to

48. 20:50

    with children that's make sense and so what happens is at the very top you have the root of the tree which also has a hash and now let's say I want to prove to someone and so that has a snapshot in the block alright so this is how a theorem or Bitcoin work they all have this Merkel Merkel state root in the block and now let's say I want to prove to someone that the the state you see

49. 21:14

    this like little highlighted green blocks at the bottom I want to prove to someone that the values there I what I'm saying they are what I'm going to do is I'm going to send to the people those values and also I'm going to send them all the remaining highlighted green hashes and from here the recipient can actually verify that that information is sufficient for them to recompute the root because if you think about that the the two green blocks at the bottom they

50. 21:39

    sufficient to compute the half of the thing right above them that and the hash I stand amidst a fish to compute the hash right above that and that thing and they have on the far left is sufficient to compute the root right and so if the T was taller in reality I would only have to send log M hashes to prove to someone the state at the bottom right and so now for me to to prove that the block is invalid all I need to do is to find the first invalid transaction

51. 22:02

    and let's say that this state is snapchatted between every every two transactions and then I'm just saying here is the invalid transaction here is the stated touches I don't need to send the full stage as the state the transaction effects and here is the Merkel proof of the state before and then anyone can the recipient of the of the phishing attempt can now recompute the Merkel route after and confirm that it does not match what what the

52. 22:26

    incorrect block contains right there's a problem with that if we have corrupted a shirt right so so so let's say validate this change over time and so at some point in the shirt the the validator is a corrupted and so two of them are corrupted these couple honest ones but this sufficient number of corrupted wants to to create that station right so two-thirds plus one that corrupted and

53. 22:50

    they will create an ad station on the block they actually never have to share the full block that's a huge problem what they will do is they will share the header of the block they will say this is the Merkel route this is the previous block this is attestation that the block is valid and that's all they going to send they cannot send the full block the blocks if all the blocks were passed around between all the shirts that that would completely congest the network

54. 23:12

    right the only exchanging headers and so they would send the header to a light client where light land could be a person who uses it or it could be a validator of another shirt that received that block and so now a fisherman needs to prove that that block is invalid but they cannot prove that the block is invalid because they never saw the block the block was never actually shown to anyone right because the validator is

55. 23:35

    the malicious validates could attest to the block without that they know the block but nobody else does right that's make sense so effectively they can they can hide the block from everybody and the problem is that first of all next validators cannot continue building the block chain the block chain can stall to begin with but also they can if they remain valid it is they can continue building the block chain without revealing the blocks and so nobody will be able to challenge

56. 23:58

    me invalidity cool so data availability is significantly more complex problem than state validity that we discussed before the invalid state transition because you can prove that the state transition is invalid you cannot prove the data is unavailable like if you think about it if I try to go to someone and say you know this file does not exist on the Internet by the time they check if it exists it can exist right you cannot prove that something does not exist all right you

57. 24:23

    cannot prove that God does not exist for example cool so these these some research not very much on this topic one of the more prominent papers is the paper from Mustafar from chain space and it became quite famous because of another co-author on that so that paper explains a very very complex construction for data volatility proves there are more easier constructions one of them is used by polka dot they all rely on the same underlying idea the underlying idea is the following imagine you have a block you cannot send

58. 25:02

    the full block to all the people that would be too expensive what you can do is you can split it into parts like let's say we split it into 100 parts and send one part to each part a different person right so now 100 people collectively have a block the problem is that if at least one of them does not share the part the block is again unavailable and so what you do use this technique called erasure codes where you

59. 25:27

    start with the same amount of data so the last left 4 is the original data and then you build in a specific way more data such that let's select let's say here I have 8 parts you can build it in such a way that any four of them any four of them as efficient to reconstruct the block right and so what you do is as you have a block you split it like let's say block is X X bytes you create three x large erasure code such that any one

60. 25:59

    third of the of the POE of the of the chunk into which you split it of the parts is sufficient right and then you send it one to each validator so then for as long as two-thirds of validators are honest and one-third of them are available you can deconstruct the block right so that can prove your data is available if you cannot prove it's unavailable so it's not the full solution but it's at least we're getting there and so after all

61. 26:25

    this we started solving some we started answering some questions but that we actually ended in the state where we have more questions than we had before we started right so first of all we actually still have no idea how to ensure state validity under adaptive adversary we didn't figure out how to ensure finality with fishermen right if all the shirts can fork out at some point that's a disastrous situation for example aphelion today has an invalid block few years back right the Dow the

62. 26:49

    Dow of work we cannot for the entire theorem just because we'll agree that that block is invalid and also we still like we have some idea how to do data availability but it is unclear how to make it make people accountable and so that's something now let's actually finally talk about well fission so well phishing is the new sharding design that we did not commit to yet but we're actively developing it right now it's a

63. 27:13

    we published it on earth research couple days ago so feel free to join and bike shed if you if you find it interesting so let's get the quick overview of it so the first role it has two roles the first role is block producers the block producers that people who take a lot of money and so if we call things with the names they actually are that those would be whales right and so whales are

64. 27:37

    producing blocks they don't have to be whales they can be sampled but for some please - let's say it's whales and we will model it not as multiple short chains on one and one secure chain we will model with just as a single chain where every block contains data for all the shirts it's just that nobody ever observes the full block people always just observes part of it people always observe parts of it and let's say we have eight validators a

65. 28:01

    block producer story and we have exactly eight charts so for simplicity we're going to say we have as many block producers as we have shards and we will assign groups of four so we will assign the first four validators to the first four shards the second the next four validators to the second to the next four charts etc and they will just take turns producing the parts of the block the

66. 28:23

    correspond to the chart we call them chunks right so here each color represents a different validator and you can see like if you follow the pink one the one that starts at the position five in the very first block you can see it produces the chunk for the short five in the first block for the sixth for the for the short six in the second seven eight and then again five six and they

67. 28:41

    continue rotating right it would have been simpler if every block producer was just assigned to a single shard the problem would be that if one block produces God goes offline the entire shirt stalls here for a short of studying it for block producers to go upline and you can you can configure it right if that is too likely you can make ten work producers rotate over ten charts and then we use that technique about the Razr codes whenever block produces produces a block they compute

68. 29:11

    the erasure code and they send so these 100 validators let's say or like let's use eight from the previous example these eight validators they will create eight part such that any how many is that - any - - a sufficient to reconstruct and they will send one part every validator and so at this point for as long as at least two-thirds of validators are honest any block will be achievable and after that and effectively for every block they reach

69. 29:42

    consensus they can use tender mint on any consensus they need to reach a consensus on which blocks effectively are available which chunks are available right so what happens is for every block they will all gather together and each of them will say this is my chunk and and I sent you part of it to each of you and they will all only attest to a block if they actually have their part of every chunk that is that is included in the block and so what that means is that

70. 30:06

    if the block has 2/3 of signatures that means that every chunk which is in the block is retrievable does make sense cool now the problem is these four validators Porsche art and they'd known in advance right that's very corrupt able it's very easy to go out there identify the for both producers and just pay them more than they staked which would still be as again significantly cheaper

71. 30:37

    than corrupting the entire system and so what we do is we have fishermen who fish whales so it's well fishing right what fishermen do this significantly more fishermen let's say these these ten ten times more fishermen or hundred times more fishermen than what producers and what fishermen do is so let's have a concept of an epoch the epoch is a period of time when validated when whales and fisherman's do not change right so every epoch we might want to sample them but within the epoch they don't change at the beginning of the

72. 31:08

    epoch every every fisherman uses a random number generator which is it's called verifiable random function it's something that a person who has a private key they can use some sort of randomness and the private key to generate some random number that only they will know so knowing the public is not sufficient to generate the same random number but later they can prove the random number using just the public

73. 31:31

    key that's make sense so if I go at the beginning I'm using like I roll a die and itself tells me six but based on my private key so I know the six nobody else does and then sometime later I can say well that was actually six and here's the proof and everybody will be able to verify that it was actually six and so what we do is every every fisherman uses vrf and they get a bit

74. 31:53

    mask of the short they will be very fine so they sample four or ten charts they will be will be verifying and they're not telling anyone which charts the very fine right and so what that gives you this idea comes from this is not a novel idea Al Gore and he uses it and a robbers the card a nose or slash Coda's consensus uses a similar idea the idea is that if you don't know whom to corrupt it significantly harder to

75. 32:16

    corrupt it's still possible but it's significantly harder because you don't know whom to reach out to you effectively have to broadcast your corruption request and expect people to go to you and prove to you that they actually people who possess the the power you need so what you do next is when every people there is a blog that is being produced for multiple shirts and so let's say so the beat mask was 0 0 1 0 0 1 so we're validating shorts 3 &

76. 32:40

    6 and so what you do on every block is you download and you can always download the blocks right because data availability is ensured you download the blocks sorry the chunks for the charge validating you validate them but you're not signing just on their validity you're signing on the entire block and so the purse the nobody just from your signature can infer which will charge you validated right so that's not a

77. 33:05

    sufficient that's not sufficient yet why because let's say at some point one charge was invalid right and you so the biggest problem we're trying to solve here is that the fisherman might choose not to validate anything they might choose just to sign blocks and get their reward right and then we don't get any security from them so we need some way to know that they didn't do that and

78. 33:27

    because there's so many of them we cannot have each of them produce a unique proof of their computation just verifying the spoofs would be expensive and then people will just open up to verify proofs and again we're not getting the security so what we're doing instead is what fishermen do is they so let's say the full block one was produced and the fishermen need to download state they need to validate it first of all that will take time right so there is no way for fishermen to so

79. 33:56

    let's say we allow ten blocks to pass before they they pass their verdict and so within ten blocks after block one they need to commit to a message either yay or nay what commitment means is that they stirring something on the blockchain from which it is impossible to recover what the message was whether it was yay or nay but they will be able to prove later to you what it was has make sense right and so within ten blocks they committing yay means

80. 34:19

    whichever charge there was assigned to I notice I'm still not saying what shards were but whatever charge I was assigned to they were all valid and then later by the block 20 I need to reveal that I need to say oh it was actually a right and and at that point so if actually I will be posting at some point I will be posting two messages per block I will be posting commitment from for something within last 10 blocks and my reveal for something that was let's say 20 blocks

81. 34:46

    away ago now what happens is and if I post may I actually say which block wasn't correct right and then as a reveal may I also reveal the proof and so what happens is let's say that we have two fishermen and fishermen one is lazy they're not validating anything and fisherman two is actually proper fisherman or fishermen one could be malicious they might they actually might be intentionally trying to diffusion

82. 35:11

    correctly and so block one was invalid so block one had an invalid state transition all the block producers were corrupted by block seven the first fisherman came in to be a fisherman one either because they lazy or because they malicious they commit to a even though the block was invalid and fisherman took Aniston a by blocks the team for fishermen when it's too late to say Nate because they already committed to the

83. 35:33

    outcome yay and so what fisherman Wanda fisherman too does is they say they review me and what happens when when someone reveals nay and and it is proved to be the case so they revealed name they provide the proof that the block was invalid at that point all fishermen have to immediately reveal their bit masks all right so if you don't reveal a bit mask you get slashed effectively canceling the bit mask is as you presume that you're doing that because because

84. 35:56

    you have the bit and you trying to to hide and so if I if you don't reveal the mask or you reveal the mask and you have one in the bit mask or the chart you get slashed that effectively means unless you also you will make obviously if you reveal Nate's all good that means that you did your job properly but if you revealed if you cannot reveal may or he or you cannot reveal the mask you got slashed and so what that gives you is that for a fisherman for lazy fisherman the affected taking chances that all the

85. 36:21

    blocks actually correct the moment there is an invalid block they will get slashed because they they didn't catch it and the malicious fisherman because notice that when a fisherman were sampling bit masks there was no way for us to tell how many the exact number of fishermen are sank to be short right because every fisherman sample charged independently every shard and expectation will have let's say four fishermen or like 1040 fishermen but we

86. 36:44

    don't know the exact number and so even if you as a malicious actor manage to corrupt let's say let's say 40 of them so you identified 40 of them they revealed their bidness to you you still don't know if there is more right that's actually very similar to to something that fluid is just presented here minutes ago and so because of that as a fisherman you always listing to be slashed if you're not doing a job properly cool so quick overview of why

87. 37:09

    this design the beauty of this design there are a few things that it solves that are sort of problematic in charging today problem number one is that corrupt the corruption is very hard in a sense that if you want to corrupt a fool shirt you need to you cannot reach out to people who are validating the shot you don't know them so your only option actually is to broadcast your intent to crap the third and have people reach out

88. 37:32

    to you and prove to you that they validate in this heart right but because you broadcasted it you brought attention to yourself at this point the entire system knows that that the corruption is about to happen right second second the data availability story is better it's still pretty bad in the sense that yes if 2/3 of 2/3 respond people are pretty providing you block parts it's all good

89. 37:56

    but we're saying that block producers can be corrupted meaning that if they are corrupted the data can actually become unavailable so more progress needed on that side and and so in terms of finality effectively what we're saying is if the phishing attempt happens within 20 blocks then this is Duncan rollback right so you know that you need to wait for 20 blocks to get the full finality if within 20 blocks

90. 38:17

    phishing attempt did not happen and that point blockchain went so far that that forking out will actually cause quite a bit of damage so that at that time the proper the proper effect is the proposed behavior behavior is to keep the invalid state and use Unchained governance or off chain governance to actually do with that so either apply apply one off state transition which is which is custom or

91. 38:48

    just say well we you know we didn't fish it so the tokens demean the tokens are there and so in this case effectively having you're having 20 blocks analogy but what you have a risk of of having to two years or two to some sort of governance but effectively that that's what you know if someone means 1 billion tokens we have to resort to of chain governance cool so that concludes my

92. 39:11

    core part of my presentation a little bit of also of information about what we do besides building here we have another project called white board serious where we invite other protocols to our office or we go to their offices and we talk for one hour about their technology in front of the white board and those are very technical conversations the first one what was with cosmos who's going to be

93. 39:37

    talking right after me and today we have code master theorem polka dot we're going to be releasing coda and quark chain shortly we talk fluent and there's a total of 15 of them maker Dow and that's a great resource to learn about those protocols usually usually this one-hour video will give you way more information than leading white paper and the link is near the ice layers WBS whiteboard series if you want to play with mere if you like my demo at the beginning the idea is near-death and

94. 40:08

    we have incredible documentation at dogs dog near protocol calm finally we as I said we insanely committed and devoted to usability the only other thing we equally devoted his vanity metrics so please follow us on Twitter who thank you questions we don't have any applications built in here but it's obviously going to be meme Jam actually there is a website built with near so check it out

95. 40:50

    it has few applications built on us any other questions awesome thanks a lot