Send Endorser Formula with airSlate SignNow

Send byline endorser

hello I'm Yvonne cough and in this video I will try to explain what endorsement and simulation is this graphic actually looks quite complicated but I'm sure after I explain you what everything means you will find a really strong logic that is quite easy for understanding so what we have here we have diagram for two organizations that are actually part of the same network and they are part of the same channel so the organization one has trippy has three peers and organization 2 also has three peers they're configured they are in the same channel everything is working there can see each other on a network level they exchange data they're in synchronization so what's happened we have the SDK not J's Java Python go you choose doesn't matter so you want to execute some operation for example we have to change the ownership of some asset ok we create the proper transaction we take the certificate from certificate authority we embed the proper attributes inside the certificate if we need them we provide the proper arguments for the transaction in this transaction is prepared from the SDK and it's called transaction proposal because we propose a transaction to the peers in this transaction is sent to one or many peers so in in this situation nothing is change inside the ledger not exchange the pure accept this proposal and simulate it so it will execute it with the current version of the ledger I have to mention that every peer has a different physical copy of the ledger in the blockchain they are all synchronized but there are different copies inside every single peer so an simulation will be executed what will be the result after this operation is executed and the purely technically speaking the result of this simulation will be so-called a read/write set and actually this resort contain okay this particular key was updated from the simulation and the new version is that so this is the simulation it take the transaction proposal and execute it over the current data and the result is this key will be updated and this is the new value and this is done on every single pier that you send the transaction you can send it to one or may later on we will see you will see why this is important so the pier actually take this result and cryptographically sign it and do a lot of other stuff and send back and those want to response to the SDK so this endorsement response holds the cryptographic materials of the pier of the transaction and the retried set so after that the SDK collect all the responses all the endorsement responses from the peers and also pack them in invocation requests for example they may they may be different type of requests but let's say invocation request and also sign all this package with all the endorsements with the key so this invocation request is sent to order this is really important order verify all the cryptographic materials verified the police verify a lot of other things but the policy is really important because we execute a particular chain code on a particular channel and this chain code has a particular policy and if for example the policies that all the members of the channel must agree on the only result but we sent the transaction proposal only to one peer then this policy will not be valid and the order will say no this is not valid invocation request because by definition you have to provide endorsement from every single member of the network but you give me only one or two or three less than oh and the order will say no this will not be committed inside the ledger this will not change the state of the ledger but the order will or that transaction it was store it in the blockchain just will not update the state of the ledger this is really useful because later you can go back in time and see what's happened who was the initiator of that request what certificate certificates were used what was the retried set so you can do a really serious or audition to see some holes or security issues whatever so this is really important part of the order it verify that the policy that is required for updating is actually is there the other thing that the order is doing is to verify the readwrite set from every single endorsement response they must be the same this is the tricky part they must be the same so you have by definition peers that have the same nature the same data anyways good the same chain cut so you have to have the same result so for any reason if the result is not the same then the order will say okay I have a mismatch of the data some peer is out of sync or is compromised or something is wrong I will not invoke that request I will not update the state of the ledger but again this data will be stored this at the blockchain so you are able to verify tor audited later so let's say that the policy of the chain code is correct and all the peers the readwrite set for every simulation is the same then the order is sending the data to all the peers every single peer that is part of the network and say okay I have a valid transaction please apply it to a ledger and everything appear except the same retried set and apply the same read write set and they will be on the same stage because you start with all the peers in the same stage and you apply the same operation every single verse every single appear so the result will be the same for everyone and actually the is one really fast and easy way to keep them in sync in synchronization because they apply the same operation with the same result also the order is responsible for for deciding which operation is first because as I mentioned couple of times you have to start thinking about hyper ledger as distributed system imagine that there is a request from this SDK but in the same merely nanosecond moment another request from another SDK for organization the games so which will be the first because to have at this deterministic operation you are every member of the network must execute the same operation in the same order so the ordering service take this invocation request do the verification order them and then send this order with all the read/write set to the peers and they will plan on the same order and see there is ordering service in organization 1 and ordering service in organization - this is the proper way how you have to do it in production because if order service in organization 2 is compromised there will be a mismatch between these two orders and the invocation we will not not be executed if there is a compare if both of them are compromised they have to bring the same result which will be which will be quite difficult so every single organization has its own ordering service and it's taking care that its own ordering service is not compromised so if somehow somebody is hacked for example or something Bad's happened the network will understand ok something is out of sync something is not correct here I will not update the ledger I will store all the information about this transaction so later that means can see what happened but I will protect the ledger so that's the main idea of the endorsement and for for the order you simulate so actually you take the current state of every single peer because the state be the same in the result must be the same if the result is not the same that's mean that the pure is not in the same state so it's mean it's compromised or something that's happened okay we stopped the operation and the order actually ordered the proper immigration requests and send them to the piers and also orders between different organizations look each other who is wrong and who is right so this is a really strong security model so actually this model is able to prevent double spending problem quite efficiently so if you're not familiar with this double spending problem in the concurrent system this is inherit problem in concurrent and parallel systems so let's say that I have 10 bucks in my account and I want to send them to Alice okay I'm executing the operation to send this money to Alice but at the same moment that's exactly the same moment I'm as good in the same operation but to send ten bucks to Bob so it is possible because of the concurrency of the operation ten bucks to go to Alice because in ten by ten bucks to go to Bob because while the monies are transferred to Alice they are not removed from my account so when the verification is done do I have that money to send to Bob the answer will be yes but later when the operation to Alice finish ten bucks will be removed from my account and later when monies are sent Bob again ten bucks will be removed from my account so I have minus ten bucks this is a really simplified version of the double spending problem but it's a really serious problem in the concurrent and parallel system so what's happened here and how this problem is solved here it's quite simple when the simulation is executed you have the read write set but also the keys that are used for simulation are also in the read write set and every key has a version so if we start with the completely empty ledger and let's say that we have we had a vehicle let's say this is the asset we have we had a vehicle and we have all the properties about the vehicle etcetera etcetera and we use the VIN number of the vehicle as the key so when the first time this key appear it will be version one later if I update something for example change I'll change the ownership or change the color or the registration or something else on every update of the date of this key its version will increase by one so first time is one next time is two next time is three next time is four so when the simulation is executed it will store the keys and in their version so what will happen in concurrent operation when we have the version of the key imagine that we have operation from the SDK the simulation is done and the particular key has a version let's say one this endorsement response is sent to the order order verify verify all the crypto materials etc etc it's everything seems ok but meanwhile while this process is happening here some other transaction update this key in parallel while this is following this complicated path it will take up of milliseconds it's completely possible some other transaction to update this key but when these key is updated its version will be updated to and when the first operation actually is sent to the peers for invocation the peer and order will check ok I have to execute the operation to this key and the version of the simulation was 1 what is the current version of the key right now oh it's version 2 so between the simulation and actual commit of the data somebody somehow was able to put a new version so this simulation is no longer valid because it was executed in the best of the previous value of the key so the operation will be removed will be rejected again it will be storing the blockchain but we will not update the ledger state which is really important so this is how the double spending problem is solved inside hyper ledger fabric in this is really efficient way because you simulate you have ordered it ok that was the data that was the version that was the result all the crypto verification ordering policy purification are done it takes some time and before the actual commit final check is done okay is the key version correct from the simulation and the current that is the legend if yes okay then it's the same ledger nothing was updated in this particular key so okay let's update it or know somebody update the key meanwhile while we're doing all the endorsement and crypto verification so in that case it's rejected it's quite simple but really really effective and it's bulletproof actually you cannot cheat that I'll give you a simple example in a tell you you probably heard that many times Jerome has been hacked and many tokens were stolen and some of these attacks actually were done because of the flow inside the implementation of the of the smart contracts let's say on a hyper ledger actually the biggest deal actually was a result of bat implementation and using not exactly similar system like the boss spending but using a flow that was not obvious they were able to to millions and millions this approach is bulletproof I mean you cannot cheat it because as you see before the actual commit you you treat you check order all the requirements you cannot see that and actually this is the way how hyper ledger fabric works of course I don't I didn't tell you a lot of technical details about the policy about different type of how for example if the order is Kafka how they synchronize that there is a queue and this queue you can control the size of the block or by size or by time and this is the main way how you can improve the performance etc etc but if you understand this basic flow you really understand how hyper ledger fabric works and later you have much easier time to understand the technical details you will understand ok why I have to send this transaction proposal and receive some response why I have to vary descriptive materials widest readwrite set is so complex why the order is doing the things that I'm expecting to do you'll be able to answer yourself a lot of questions so just to recap it with couple of words the SDK send the transaction proposal to one or many peers the peer simulated and give the result of the simulation and also are the inside these results are the key with their their version in the time of simulation this thing is returned back to the SDK it's combined it script to refuse design and sent to the order order verify the crypto signatures verified that through retried sets are the same from all endorsements responses also do a lot of other stuff and say ok I will order to the peers to update this readwrite set because the immune equation is correct and for that the keys and their versions are checked if the versions are ok then the operation is applied by every single peer inside the network and they will be in the new state so every other operation actually we work with the new state there is some some important stuff that I want to mention the order don't do not execute every invocation request directly there is a queue and you can control how big these two can be so excuse me so the order actually collects let's say 10 transaction or a hundred transaction or 10,000 transaction depending on your needs and when the number of transaction is enough it packs all this transaction in a block and the cryptographically sign hash this block and then this block as a whole is sent back to the to the peer so what why this is important imagine that you create some really big number you configure the order with some really really big number of transactions for example let's say 10,000 transactions but you operate with the rate of one transaction per second so there is the case putting some transaction it's in the queue but stays there it's not committed directly to the pier at that stay at that point in time the ledger is not updated the transaction is there but the actual pier is not updated so if you put another transaction these are a transaction we work with our date of the pier and this will be okay until you reach the maximum number of transactions per block let's say 10,000 and when this number is reached you actually the order actually we'll take all the transaction and send them and as a batch to the person they will update the state at that point so this may cause problems because if you have a huge book that you cannot view in a realistic time a lot of transactions will be rejected because after they are ordered by ordering service for to be applied they will be mismatched between the simulation and the actual result because they will be applied in order so the first will be okay but the second was simulated with the older version of the keys and will be rejected so you have to be really careful what is the size of the block and also you can limit I mean you you can decide the maximum size of the block or the maximum time so you can create it like that I want to execute commit every 10,000 transaction or every second so which one first comes first will be executed so it's a tricky part but it's a configuration option you can change this thing dynamically you don't have to build completely new network but just to know it that this is the way how it works it's a queue this view has the size and/or time limit and when the size or the time limit is reached then all the transactions in the queue are packed in the block this block is signed cryptographically that's why it's a blockchain and then it's sent to peer for applying over the ledger so this is the basic concept the things are not from a technical point of view are quite complex because a lot of cryptographic verification signing etc etc is really not not trivial but the good thing is this is completely transparent from point of view of the SDK so as a developer you don't have to be some cryptographic guru or what or something some security expert to use it all of this is handled by the SDKs and the peers by themself so from the point of view of the SDK you just execute operation and you wait for the result okay it was ok it was committed or it was rejected and the reason for the rejections so it makes the usage of hyper ledger fabric quite easy because you can actually put let's say REST API on top of the SDK and start connecting for example angular application directly to the SDK in directly to the blockchain so this is really really clever way to implement a hyper larger fabric so this is for that video thank you