Whiteboard Series with NEAR | Ep: 17 Alexander Demidko from Fluence Labs |

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

1. 0:03

   hi everyone this is Alex from near protocol and with me today is Alex from from fluence labs and we'll talk today about the centralized databases Alex would you like to introduce yourself and share hi i'm alex and i work at fluence as a researcher and today i guess i will talk about how to build structured data flourished in the distance wise fashion cool would you like to give an overview

2. 0:25

   yeah sure so what we looked about you know that there are unstructured data storages in the like in distant voice ecosystem but there was no many structured data storages and so we thought that probably we should build something that will allow people to make various to the data and basically be sure that like the results that are returned to correct and to give you a brief very brief overview how fluency structure it we have few

3. 0:58

   different like I would say he's or a genius confidence here so the first one is the thing that we call real time where and the real time layer consists of multiple small let's put it this way beef tea clusters I can make one bigger I think that's the beef tea OneNote is also 50 so we're really small ones really small clusters the beef tea ones and because they are really small there is a chance that some of these machines

4. 1:41

   can you know go wild so in order to keep those guys in check we use a share it validation layer and the validation where is shirt we usually use this you know symbol to depictive our data because it looks like we and this is basically shared validator spool and we call this thin a security layer and it's the same participants in both layers well I mean they might be I mean you you can have I mean you can have this is different software in some kind

5. 2:23

   of but you can have this like one single hardware machine to run both the real-time node and a validator so the way it works I mean how do those guys keep each other in check is that real-time we're basically uploads every time when well there is also client and here's the client and I will draw a mobile phone in the sense that we want those clients to be seen like I won't say white clients but like at least in clients and um so the white client or

6. 3:07

   the thin client interacts with the real time we are only and every time like the way how interaction goes the client sends requests which is like transaction essentially and receives a response from the real time where and for the validators for the security where to verify the real time where the real time where stores transactions into a decentralized storage and for this purpose we use like swaram you can also

7. 3:38

   use file coin I mean honestly right now we expect that in theory those storages you support basically in like if say for example if you take a look at this one paper form paper talks about how it can force nodes to return you the data you have put there basically to how to guarantee that it will return the data there and if it will not return you the data then like this knows who's the deposits but if you look at what swarm

8. 4:09

   does currently have in you know what deployed they do not have this like incentivization layer so we expect that eventually once they have this feature the data store there will be but for now we basically built on theoretical guarantees that it will bit one day and we call this in the data availability where okay so we not only so first of all the transactions are stored here and I would say like transactions here are storage in blocks

9. 4:53

   so the data will be little error has basically keeps this real time where blockchains also we store and in this case the block is just the set of transactions right or queries rather same thing yeah I transactions here not sure if it's visible or not so that's I would say the transaction history and um oh is it wait okay sure okay so we'll call this transaction history and also the data

10. 5:43

    mobility where source states so basically state is a snapshot of the real time where at some point so the way how stuff works how frequently do you produce the snapshots right so I'll get I'll get to this so the way how stuff works the The Bachelor data comes and it reads the like previous state snapshot like say it's not so state m and it reads a fragment of transaction history

11. 6:18

    and then it produces the new snapshot and this new snapshot goes here like into the storage and the BFG clusters never produce snapshot it's from the validators I see right yeah because like you don't want those guys to produce snapshots I mean if even if you take like security aspect away I came in producing a snapshot avoiding it here it's a very different property from the like a Creole I'm saying it's more expensive yeah well it's I mean it basically will

12. 6:53

    make the water on those classes irregular I would say it's like yeah so those classes I used to for example a steady transactions like in common rate but once they have to upload the snapshot somewhere that's kind of like might decrease the ability to process transactions so no those guys do not do not process name shots so only what liters are produced snapshots so yeah they basically read those transactions

13. 7:23

    this history and snapshots and produce the new snapshot if during the block processing they do not agree with him basically with the results they get they can file a dispute so but first of all let me get to how do they not agree so in the end of the of each block we like the currently here in the real-time where we use tender moment as the VFD consensus agent essentially so in tender mint after like in the end of each block you also you not only put transactions

14. 8:08

    there you also put the hash of your state and that's also is stored here in swarm so we have like for example after each block we have here Hershey virtual machines and half of your machine sub n plus 1 h vm sub 1 plus 2 and so on so what datums go over those blocks and if basically when they are trying to apply a new block to the current state if they produce a different hash then they're like okay I mean it doesn't work

15. 8:40

    out so let's basically point the garment to those guys so when you're saying a virtual machine so effectively you literally the state the state is not any sort of an abstraction you literally snap setting the state of like the memory dump no I mean of the virtual machine that processes quiz no no I mean like when I'm so heavy it means like the Mogul right but what is virtual machine okay good question I forgot about that

16. 9:10

    so we used web assembly and yeah like every node has the same like virtual machine instance and these like like basically it's the memory of the virtual machine and here we take the half of this memory and that hash it's not an organized in any way right it's just the hash circle it's more like yeah and anyways so we've got like those guys free transactions and those guys read snapshots and if they like for example

17. 9:43

    one of those for the 80s dot instead of hash have some BAM it got hash sub-brand prime it clearly like doesn't match and they submit a dispute and they submit a dispute to theorem okay so once the dispute is submitted to a film well those guys have to I mean a film is obviously is not able to download the entire state and is not able to don't her downward even the block I would say of transactions to

18. 10:30

    basically replay that what those guys are doing they are playing a concept code verification game and that was basically proposed by true--but and the way it works like you execute a program instruction by instruction and if it's some instruction you found that you're basically your stage you have achieved different state then you counterparty then you say well this instruction is the bad one and you don't have to do this like in a linear fashion you can do like a basic search so once those guys

19. 11:04

    have found by the instruction they take the chunk of the state that is was used by this instruction as an input like say for low I mean at not an expense for example if you have instruction I set you to add this instruction obviously uses this stack it basically takes two Whaley's from the top of this stack here and it then pushed one value back to the top of the stack and it consumes those

20. 11:37

    so it's like pop - and this is why push one so in order for the like for the virtual machine on a theorem to operate you have to give it like this chunk of memory and you also have to give it the chunk of memory where this stuff you'll be written do you effectively need to have the entire was over to machine written in solidity like like a like a worry like a very small implementation of that actually true bit guess almost for rigid nice but but then you also need the hash function which will be

21. 12:08

    capable of doing hashes where on the part of the state changes right well it's still about these markers it's notarized yeah so you can build only the half of the chunk and then you compute the the entire hash the problem is that it still might be too much for a theorem smart contracts and so we are looking and how optimize that because like the chunk like it might be four kilobytes and transferring four kilobyte still might not be also like like the brightest idea anyways so once

22. 12:40

    those guys have pushed this into the virtual machine on a theorem it basically execute the instruction produces then you have and basically the machine that has a different hash has produced a different hash or it was acid steak essentially I probably should talk about a little bit about time outs because that might be I would say in personal security or if you but so so in terms of you saying that so snaps art is created once every few

23. 13:11

    blocks right like ten thousand blocks maybe yeah let's say let's say for simplicity okay so we have snapshot here right and then we have some right here so in the model you described so far there was a single validator who could either trade yes yes there are multiple of them but if there are multiple which of them which they do uses they can so multi you say multiple validators will

24. 13:38

    be assigned to this particular what is called fragment yeah a fragment which so each of them will produce the next state which one will be used as a canonical state well if all of those holiday tours agree if all of them received the same hash then like only the first one who has a port at this state like is I mean has to upload this state if any of those validators disagree they also have pay the same verification game between each other it's like you don't actually like

25. 14:09

    either they all agree or like if there is some disagreement then someone will like lose money and of all this information what is actually snap suited to a theorem the way a snapshot every block yeah I say and every snapshot as well no I mean well yes wait wait like a hash of every snapshot no okay was there was there was one more thing yeah yeah you because like you don't want to upload the half of each block to assume that also you'll be too expensive

26. 14:41

    so we have a separate layer we should probably probably should talk about let me I mean once we got to the validators model let me let me describe that I guess so you can man should be like if you mentioned multiple validators so let me try to explain how that thing works so first of all voters are selected completely by random from the validator spool and the way it works basically all the active editors they have to register on the theorems must contract and then you have a like Randall random number generator that you

27. 15:23

    can use to choose one of those auditors and evaluator once it's like selected it must it must execute the history fragment otherwise if it does not do that within a certain time out which I probably should talk about so I will I will put a reminder for myself here time outs in in this case it will like who's it like a small fraction of feasible it's like it will not with the entire deposit because it's like like a minor offense but it will was like a fraction

28. 15:58

    of that um so the way it works so once you have selected one void ATAR and this whole data is verifying this beefed equals rate now you after this auditor you also select another validator and you also select is for date by random from the entire pool and what else happens like once when this way data is selected it does not know if there will be another validation or not so the way it works we are saying that and what the

29. 16:32

    next validation will happen with the probability P so this means that because in this case it will be geometric distribution in this case the expected value of the number of validations will be P divided by 1 minus P so if say for example you put I don't know what here like P equals 4/5 then in this case this will be 4 yeah so you can you basically can can control the expected value of the number of validations but the idea is that you you

30. 17:11

    don't really know if there will be another validator or not so the raw data that goes last so here we probably will go yet to the proof independent equation this was proposed by Jason Drake the idea was that each validator when it valid is it has to provide basically build like I would say a fingerprint of the execution and this fingerprint of the execution is specific to the activity so later only so this hold it will produce the proof p1 this will

31. 17:46

    produce the proof b2 and this will produce the proof p3 and also while this void is is like performing the verification it will like well this one it will verify the proof of this validator so because our daters don't really know if there will be another word data after them or not they are like I mean they don't have much choice but not but the idea that here is that if I as adversary

32. 18:19

    control certain number of validators there is never a moment for me when I'm certain that if if I fake all the so so let's say I managed to fake few validations after certain extent right the idea is that even if I know that even if I control the next validation I still have a risk that the this one that is going to at least one more right but at some point it's actually one more oh

33. 18:42

    wait you say you say at every moment so if this is this will you manage to get to validation number 5 then the probability of next is still 4 over 5 yeah yeah so the ya hear that the geometric distribution is memorize so if you are here for example the expected number of validations is 4 if you are here for example the expected number of validations it's still 4 yeah it's like

34. 19:06

    if you want a girl and you you have a boy you still have 2 kids before you get the girl well and basically yeah this guy doesn't know whether there will be a validation after him or like wishful with this or but importantly the probability of the next validation is always high yeah and but and also you I mean you can you can also improve the thing by forcing not only these are data to verify this one but also like this for data to verify this one the proof independence equation but what is the

35. 19:41

    motivation to veil like probabilistically they will look dyslexic you stuff and so if you if you do if you verify the proof of the independent execution most likely just waste resources right was the motivation to verify it well in our case the idea was basically to make the computation of the proven execution really like the overhead really well so you don't have a reckon incentive to remove that and also

36. 20:05

    the idea is like if you catch this guy like that this guy has produced an incorrect or maybe an execution then well you you you go get a fraction of its like of this guy deposit but I mean yeah I mean in theory like you could like I would expect someone to go and modify the source code and remove this like proof indeed an executioner figure also the idea right now is that if I'm

37. 20:27

    validator number five as I'm executing the code of the query whenever I need to compute my well we didn't go much into proof from independent execution but whenever I need to compute my hash of the state in the present binary I will also compute hash of everybody else yeah and you're saying the incentive to recompile the binaries it's like very low so if the the overhead is very well

38. 20:50

    and and you also have some like you can also receive some money from those guys yeah and also it also might happen that if for example and now I mean that it has like you can see why this approach might have it's like some force here so if you have this guy who is refined this proof independence equation let's say this proof and dependence equation was not correct and then this guy came and didn't check that and then this guy is coming and it actually found that is incorrect and

39. 21:21

    this guy is like okay I I have something to lose here so yeah you you maybe you can improve it like that are you saying that that was the work as a motivation for for the second validator yeah do like to actually verify the proof um okay let me probably talk about time outs because there is also again like a potential like you know problems here so the way so first of all before talking about time outs I probably should talk

40. 21:50

    about like few accounting so we use very similar like approaches like what the theorem does we use a few so the UM but here we have a kind of different thing instead of forcing clients to pay for few we have a developer who is pain to the not liked only the real time where but to the entire like to the entire you know rotation and to the all-time where person and the way how few works a few accounting works so first of all there is like a complexity of instructions which is like we read like similar to

41. 22:27

    what you found like in the theorem although we have complexity of web assembly instructions and but second thing is so first you have algorithmic complexity and the second thing is amount of allocated memory so these machines they have to allocate memory we haven't like for like right now if you focus only on the memory like you know in memory stuff you haven't only touch disk master I'm not going to talk about that but you for example can tell those

42. 23:04

    guys I need four gigabytes of memory or when once when assembly supports more you can say I want like 32 gigabytes of memory but anyway like the developer can have control over how much memory she wants to allocate and yeah so there is memory but the problem is memories memory is not really like if you if you calculate the algorithmic complexity of the microbe assembly program it's like equal to work I came in in the

43. 23:35

    physical sense but memory is equal to power all right that's way beyond my knowledge of physics my brother they see what you say yeah so it's like it's like how how much do you have your kid but if you located like 4 gigabytes for one not a second that's probably not worth much and if you okay - per gigabyte for you know like a year that's a lot so we multiply this in by time but you don't know in advance how much time you need right what happens if even I deposit and you also don't have a notion of like a

44. 24:06

    good notion of time in distance right systems so how stuff works here we kind of replace it in a little bit so this is anyways let me say this is like ever like how much the program like the complexity of the program that was executed like in a for example single like block so you can multiply this data by some coefficient and you will get some kind of standard time here okay yeah yeah how much - how much how much

45. 24:45

    how much like processing time it's been yeah how much time it would have taken on a standard hardware to execute this program and then you take this standard time and multiply it by memory and you get like how much you have to like the developer has to pay for my way how much how much memory they used at that particular time but that but then also if you if the query has some footprint on the state that memory will be downloaded by every consecutive

46. 25:10

    real-time layer person or validator right yeah yeah so the way the way it works so we have you have this thing and we also I mean remember we have spoken that we have to compute the hash of the virtual machine and we also said that the hash is like localized is in your question so imagine that that you for example need to put to perform a single put request like right just one bite into the memory but your memory is like four gigabytes and your chunks are probably like four kilobytes let's say let's say like that

47. 25:44

    so now are you saying the memory is pre-allocated yeah the mo gigabyte is pure like yes those guys have like yeah if we go bicep reallocated and I mentioned that the let me show you like the issue here you have the say for example you have a miracle tree and bring it this way and this Merkle tree has like eight chunks is like four kilobytes and I'm going to write Amazon developer have written a program that writes a single bite into chunk so now

48. 26:18

    if I'm just calculating the algorithm complexity of this thing it's quite well so writing one byte is pretty small has pretty small complexity but we're computing the macro hash of this chunk and this one and this one I can risk a propagating all the way to the top it's like pretty expensive because you also have to calculate the hash of this thing and this and this and so on so we also charge for the code for dojin

49. 26:43

    chunks so every time when you write to a chunk this chunk is like Marcos duty but it might not not much different from writing a single byte to a page which is not in the cache right yeah yeah so that's that's that's that's kind of that's kind of similar to like today it's your as a developer you responsible to to make sure you're writing to collocated yeah basically we have a Hawaiian Coulson and work right into the

50. 27:08

    same like trying to write to the same page of memory so anyways but we have like price for Georgian chunks and basically that's also goes into this for more dirty channels multiplied by like some another coefficient and that's the entire price like that's the entire fuel price how much a developer has to pay for that and if the developer might be might be compensated or might not be compensated for like this show is for them to

51. 27:41

    monetize it right yeah so you but how would users not saturate their they're a lot like developer will not be paying infinite amount of money right through some allowance why would they not come with a single phone and just saturate everybody's allowance but that's very similar to how like modern works so again it's up to its up the developer to properly expose it and write write write so I mean if you say

52. 28:05

    for example have deployed it back into its like centralized data center then I can make a DDoS attack on you and but anyways I mean I mean here we have a central developer role here which is kind of makes things a little bit centralized but you can make it more decentralized by saying well each client has to pay the work to use the service clients need to pay a developer like say for example at once in a month some-some

53. 28:31

    or pay for each transaction like somehow basically if the fall of clients is high enough then you don't really need a developer here like you just have a contract that stores like some kind of balance here but like these guys they really don't care who's paying right yeah they just need to operate and also before we go to timeout these people never rotate right yeah I mean they can but but that's not how it is implemented right so if I have my own day if there's

54. 29:05

    a data set or any computation want to do I pretty like these validators you can read that you can do that and those people they constantly rotate those I never choose and they never choose me yes yes I mean so we hold so honestly we haven't dig much into like how real-time could boot eight so for now we're like oh yeah a developer can choose the node that is more like and like has the higher like an old boot or reputation or something or better link to them yeah

55. 29:30

    but oh but a link to clients but we are we can we can say that those like this layer is not necessary you know I mean it might be taken over by malicious adversity like it might happen what's important to this we're like developer doesn't have any control over this for you but then the the interesting question is this valid data right the whenever they get assigned to fragment the very first thing they do is

56. 29:54

    they download the whole snapshot of the of the virtual machine just to perform some number transactions which I guess is relatively small right very high okay but still effectively that implies that rotation is very possible right so so wouldn't would it not make sense like let's say I want my speed layer to be more secure we did not make sense for me to say I want EFT consensus for four people I don't care about link or availability but I want more security I want those to rotate because clearly

57. 30:28

    they can write in principle I mean they could in principle but as you as you mentioned that those guys have to read out I mean so maybe I should write it like that so these guys are stateless and these guys are stateful right and let's say let's say I chose let's say I chose to have one validator in my tender mint consensus group and then I chose to have let sit like probability 6 over 7 so we're going to get 6 right it sounds

58. 31:02

    very suspicious I know that so good that means I'm already paying for six people to every now and then go download my state and validate right so in essence let's say that instead I drop this guy or like I keep this guy doesn't matter but they make those six people to to be more real-time and I'm telling them to download the stable state a little in advance and then validate in real-time for the same

59. 31:28

    amount of time that would give me a slightly less security in a sense that they the Master of Puppets oh you you cannot choose those guys right what what I'm but you see what I'm saying right I'm losing a little bit of security because the Master of Puppets now during that epoch while they validate me they know them all and so they know exactly whom to corrupt so we're losing were

60. 31:54

    losing that advantage of the last validator right so I'm losing that what what I'm gaining is that my speed layer is significantly more secure right ok let's think about this so first of all we like that was the idea I do not let anyone like to tamper with this layer so like no one actually has control over this where so we didn't really want it and the second thing let me think about this so this really data you'll go here

61. 32:21

    and take this state right and it will I mean the questions are how often do you like rotate those guys but let's say we rotate them as often as they like they would they would do as many queries as they do today effectively all the problems that here when they validate the queries are condensed right and if it's real-time the queries are sort of coming at at the significantly well I mean what could what could be done what may think what could be done here you can say take this for later and like no not not you take

62. 32:54

    this for later once this validator is selected and has done ordered the state and applied it and produce the new state maybe you could replace this note with the oh wait actually this world it will be learned because it yeah but they can download state a little bit in advance like a factory what you do is you download state like half an hour before you would have to start validating but you don't know that you will be validating well

63. 33:18

    let's say you say you they somehow dunno right but this will break the assumption that no one controls the Slayer I mean I'm not well technically someone does control the Slayer today like this this is the theorem chain with randomness which says you validate this now so what will change that in a theory instead of saying you validate it now says you validate it and half an hour from now so you have time to download state catch-up

64. 33:41

    intended in sync right so to hear the trade-off is the security will be slightly less that's that's like that's a philosophical question is it the case that like if someone can corrupt two thirds of my seven node cluster in principle they can like tamper with people who get assigned to them totally with my data set but what I get is that my speed layers fast right sorry my speed layer is secure it's more secure

65. 34:11

    yeah yes I guess I mean I would probably want to like like to sit down and do some math on that but but it is also here's another sort of consideration which is so those validators you chose them from some pool right and presumably that pool it is unlikely that you happen to to sample two-thirds plus one malicious actors or like even one four plus 1 depends on where you draw the line so we

66. 34:40

    expect that it will only break if a malicious actor can somehow reach out to them and corrupt them adaptively right by adaptively I mean that when I when I created so let's say this is my cluster it has seven nodes when I created it it was extremely unlikely that they were that the cluster was corrupted so the secure layer protects me against someone let's call them an adversary an adversary somehow reached out to them so they like for example let's say all the

67. 35:11

    validators are sitting in the same disc or channel right so they want to the disc or channel and they said if you validating this cluster I will give you your stake x2 for your private key right so that's what we're trying to protect against ok the thing is that clearly this validator knows that they will be validating your your particular fragment for a while right so let's so let's say you want them to validate for like two hours in row that means there is two hours during which the validators

68. 35:41

    themselves knows that they are validating the fragment you can do some smart construction so that nobody else knows until they publish right but but they know that's so that's what is important so now as an adversary what I will do is I will go to discord and I will publish a smart contract on aetherium where if you prove that you got a sign to this to this fragment and you provided your private key you get your stake x2 right right so I still can

69. 36:04

    adaptively corrupt I mean I'm still risking something right because I could adopt this person but I don't know if there's going to be next one or rather I don't know if they will be corruptible but different if I really want to I mean if you really want I mean so here's the thing if you really want well first of all two things because this guy knows that someone else will be the refine him and this guy might not really know that like whether this guy will actually you

70. 36:28

    know be corrupted be corrupt but I'm paying him stake x2 as incentive if an adversary is willing to spend the like all this take in this attack then yes like the adversary can all this take of seven people out of like a few hundred right yeah yeah I mean it's it's basically we can tell like the developer a price basically the developer knows that those guys have put that much stake and the auditors will put like that much stake and the developer knows that if someone spends more than this take

71. 37:00

    yeah then probably the results that like the entire where produces like you will not work but but if this is the price that developer if this is the security of the developer gets then obviously they can just put everybody onto the speed layer you still need to spend as much now the I would probably say that the in this case you so for this case in the speed where you need to corrupt

72. 37:24

    two-thirds of the class for things like to work in the security where you have to corrupt I guess everyone and in this case you will be like so it's like basically corrupt all and I would probably say that if you put everyone here so let's consider two situations you have seven nodes in real time and you have one real time six relatives exactly like 100 times 600 daters I will probably say that this is like slightly

73. 37:57

    better but but also to an extent it depends on how how much will be leaving the power of the adaptive anniversary because obviously you cannot expect all the sticks validators to be online so an adversary can provide them a choice they can either get corrupted for 2x they can lose the stake or they can just skip their style you can sound like 1/10 oh no you cannot you cannot like em in the

74. 38:20

    quantum of those four days keeps the stack keeps the validation then another lower that you've selected yeah you always have to do so yeah but but let's say we make small step let's say we remove completely the security layer or a shared validator pool yeah but we made but in the tender mean consensus we're saying that yeah let's you craft it to third but we still making like the remaining participants can still challenge right they can still fish yeah I presume yeah even one today right

75. 38:51

    actually let me think about this so what you're risking is if two of them are literally offline for some reason so think about this so I guess what what could be down here um so here's the thing so let's say for example those guys like corrupted and in this case they don't even not need to talk to the like to the rest of the - to reach consensus like because those like those guys like the

76. 39:21

    like those high enough to have concerns but we presume that swarm has some way to say that the data is not available so the two guys will they will not say block is invalid they will say the the data is not available yeah yeah yeah so I guess if those guys let me think about this so I guess if those guys are safe to be if those guys safe everything to the data I can get you later then these

77. 39:45

    could yeah I mean they are not in the consensus but they are like well someone has cut us out and they can go here and download the data in the way I Cho I like I challenge you I'll probably say that I would probably say that's quite possible so what we lose so effectively if I understand everything correctly the the only thing we're losing in this approach is that the adaptive adversary has full information on whether the

78. 40:10

    attack will be successful before the attack like in fact they can choose not to attack until they have full control while the data pool you like those guys have worked on completely random and I mean you I mean here's the thing if you saying that an adversary can post a discourse channel and say like biscuit every row it like all of the six auditors here will be like okay I'm I'm corruptible but do you know why validate has validating right that's not because

79. 40:40

    they like fluence or cosmos or whatever the validating is because they want money so if someone goes to discord and says gives more money right right right but I would probably say that's like that's also a philosophy if we are saying that all six of them are corruptible then yeah probably that's pretty bad yeah I think that's that's an uncommon opinion that you can have like large percentage corruptible but but it sort of sounds reasonable if you think about it well I mean

80. 41:06

    there will be some oh I mean what Eltham ultimately it's up to the up to the developer usually we are basically saying that like what like one thought of the holidays was a corruptible or AK malicious oh oh it's like 10% of them are yeah but yeah I agree like if all of them up can be corrupted um what I get here is if the developer like it's the developer who chooses the security right if they if they believe that more than

81. 41:30

    50% are corruptible yeah not much they can do anyway and also I would you say that yeah this takes that the world eaters have put their basically kind of saying well you can expect that much security if an adversity like say for example of those nodes have put like 10k in as a security deposit if someone is going to spend 70 K you know to break the thing like yeah right like 50 well no actually like you also need to grab those like 70 k then yeah probably like you should like if

82. 42:03

    your if your application is that mission-critical you probably should require those guys to put mistake cool okay now let's talk about timeout yeah let's talk about my mouse so we have just discussed like well be like we have few and the view is basic instituted from three components and the first component is how like what the algorithm complexity was of the program second company is how much memory was allocated

83. 42:27

    for how much time and the third one is like how many chunks of the memory we like made duty so now you have calculated let's say you have calculated fuel and once you once you basically have calculated few you can like we are trying to join this view into the timeout because we said here that a validator must validate within certain time and like if the mode that does not hold it in a certain time then a

84. 43:01

    fraction of his deposit is like slashed okay like a small fraction like one feel like one hundred one thousand one ten thousandth so how the timeout is calculated we basically take the few and here's the thing the few is declared by this cluster because you you cannot really know how much fuel will be spent without actually executing the program but once once you validate if you exceeded here you just stopped right so as a validator so those guys say for

85. 43:38

    example have like they I mean okay let me talk about the timeouts and I probably should clear some space here that's good enough so let's let's talk about timers so let's say I have I have few and I've got the timeout which is equal like some constant by few and this was like choosing wash enough like maybe 10 times more than you would expect it like and every should know like hundred maybe not hundred times 24 times more then you would expect an average validator to take and you can say well

86. 44:21

    if you guys are slower than that don't even consider during the network so now you have the real time cluster and it might happen that the real time cluster says well I have spent that much view but this view is much less than the like true amount of view that is required to perform the computation so now and this view is written here in like in those blogs how much time how much fuel was spent for like each of those works so now you can say if I want to throw a data fragment of history I need to spend

87. 44:55

    like that much view but if the real-time cluster was lying about the fuel spent then the time on that will be given to divide it is like really small and for this we have like few disputes so once of all the data comes and notices that he was given a really like small amount of time it can execute a few of this good and I feel disposed is really similar to the just normal verification game dispute you basically saying like

88. 45:25

    say for example these are two these are too like like this is a real time class and this is a validator and after each like webassembly instruction you can say hey that's how much fuel has left like I mean what Spanish but that's not how I will attack you if I'm a real time cluster I will just upload a 7 terabytes file he will not even get to AB assembly step well let me think about this you opposed 7 gigabyte file terabyte

89. 45:57

    file to swap you you go you will report it to swarm ok let's get to this that's about that but swung can can can provide and stay at the station on the size on the 5 I'm not sure again I guess this one can do that that would be your dispute rate well probably well I don't know the answer right now so probably we need to think about this so let's finish with this and then think how we how this

90. 46:22

    cannot die can be solved so anyways for the time art attack you can say each of those guys once this guy has found that he spent more fuel than this guy you can say well I want to dispute on this part of execution and then you do the same basic search and you find the instruction that has produced diversion amounts of you and like the raw time cost in this case you'll you know was

91. 46:48

    steak so for the so far the timeouts here I would say that yeah but yeah if something is wrong like let's see fuel is improperly recorded within the timeout you just need to initiate the verification game right you don't need to finish it yeah well and you you're not only giving away this time but you also have some you know some time to download this state like I'm indeed but that is all included trade yeah yeah well not including few you probably need

92. 47:25

    like another constant here yeah because I this is if you put fewer than you don't have any time so for the time out what what kind of a problem might happen here that the like date availability where like if an adversary tries to corrupt the data mobility where and say hey do not return any like any data to the evaluators so they time out essentially that might help might might become a problem and I think but in this case the system will just stall right

93. 47:59

    well no like if no validator can validate yeah I want to say yeah I'll probably say that you will like the a malicious for your time class in this case we will never get caught probably Oh actually the adversary will have to pay these guys but but but as a developer you will know something is wrong because like for a long period of time you're not very receiving any validation results yeah you'll probably see that because basically if an adversary will have to pay for the right

94. 48:30

    to the data availability like to bribe those notes or return the data but if you have to bribe them for like indefinite amount of time because like once those notes like start returning the data they will like essentially like these guys who actually comment like some like they will be another more data that we'll be able to download the data and eventually someone who's like a deposit and also with this like we

95. 48:55

    remember this we said there will be like multiple validations so the stakes of the real-time nodes are not released until the camión the real-time nodes that have produced this like history fragment they will not be released until like the reason why classification was completed so if an adversary's pain to someone to you know like to not return the data then stakes of these guys will never be unlocked and this essentially would be similar to it just paying those

96. 49:28

    guys their stakes yeah you have asked about the I think about what if let's say yeah let's think about this what if those guys have uploaded like a really big like transaction file you probably can compute the proof like you probably can do the proof of this sighs all right if swirl can attest to the size there's already quite a bit of reliance on sperm so it's not gonna get any worse I think

97. 49:58

    I think it should I think it should or what what else can you do you can also say for example you can also build in more cool I mean how it's not like house or we could do that I guess you can build an Urkel tree like I'm like on top of this file and once you have like if say for example the scene said the file is like 1 megabyte but you have done would like already 10 megabytes and it's not has not you know finished then you have

98. 50:29

    downloaded the chance that I required to build in local proof that these chunks do want to the like half of the Merkle tree and now you can actually prove that the size of the fellowship they uploaded an invalid more code you know they upload it and invalid like they actually have a 1 megabyte file which they never upload it and for the 1 megabyte file they do have the more oh that's that's that's actually like that's actually an interesting case I mean we okay so let's

99. 50:54

    let's let's also talk about this the Merkel what's what's important here is that the Merkel three of the I mean here's where the discrepancy might come from so there is a hash over this theme and swarm so there are actually two hash okay let's get to this there are two hashes actually and the first cache is the virtual machine - that's the miracle drug yeah that's one of the markers but

100. 51:24

     there is also swarm - that's just something that's one give you back right and that's something that swarm a tests that it will return to you this is by no means Merkel is right no they analyzed it is not a swarm has a Kenya and those hashes can be computed with different chunk sizes and moreover like even like different hash functions so effectively you can you can provide one VM hash and at all the different file so a road data like what of auditor can do like this

101. 51:55

     guy can come and download let's say for example it has produced a new state and it says yes the state of the like I agree with the state of the virtual machine that is written here but it then uploads not match and file an automation state file to here and in this case and because those hashes are different it's not like I mean I well I don't know of an easy way how to prove that this hair doesn't match this but if swarm hashes Merkle eyes why do you have your own

102. 52:26

     hash well it might be just different hash function I mean yes we could you could make this hash function compatible that's what we are saying here that well maybe we'll it might actually happen that the hash functions will be different so what we have thought about in that the next like I mean they will be they will always be the next validator like either the one that is really verifying this guy or the validator that is like verifying the next history fragment that will download

103. 52:55

     this file and once it downloads the file it there is a way how to prove that this file like that the file available by this form hash does not really correspond to this virtual machine hash you know just like yeah you just basically find a diversion like like chunk in the in the if the next validator is verifying they not downloading the file they uploading the same file yeah but I mean once they are ready to upload the file they can

104. 53:25

     compute the swarm half and see well if the swarm has match this one and if it does not they can also like do it this bit here yeah not time house yeah yeah I think we covered most of the things yeah I think so cool yeah yeah we can wrap up the technical discussion here we always will ask one non-technical question at the end which is when is when is the main that how far are you I think the beginning of 2020 I guess yeah it's 2019

105. 54:02

     right now so yeah we beginning of 2020 that's how target I would say and you have a definite right yep yep but you can play with the real quasars and they security waiters like on this way I say cool okay thanks everyone thanks guys