Build Up Signatory Order with airSlate SignNow

Build up signatory order

hello everybody and welcome to part one of three of these webinars to get you all ready for the barclays hackathon in 2019 so we'll kick things off now and if people join within the next five minutes or so that that should be fine I don't think they'll be getting into the code except in the you know in in ten minutes or so so quickly firstly a point of order so if you don't remember anything that I say in this webinar you should you should remember this slide these are these are your resources that you have available online for you for for any you know documentation and reaching us out for house so firstly we do have a slack channel there in fact 2019 which is which is a public slack where you can forward any questions related to the hackathon Dan'l or dabble which is which is our cloud offering for Florida Ledger's if you want to go old school you can also email us a terrific at digital asset calm down will calm is your source for both the SDK and documentation related to demo itself so things like the the demo standard library you know the components of a template demo syntax all of the reference related to demo list is there one caveat there though is that there's also a lot of documentation on our in the architecture and the API that you can use to connect to demo enabled Ledger's for the most part you should you should ignore those because we will be because we will be using mostly dabble here and there's a there's a couple of caveats that we'll get into more so in the next couple of webinars for for how to connect to to dabble it's going to look a little bit different than than what is on the documentation currently around GRP see for example lastly project dabble calm is is open and available now this is where you can quickly start up a ledger on on our cloud offering where you can quickly upload your demo bytecode and have a ledger running in under three minutes and this is this is the architecture on which will be hosting everything okay but but you can go ahead and log in there now and and play around a little bit but like I said the details around that will be coming in the next two webinars okay so this is what I wanted to do for the agenda so I'll discuss the architecture a little bit but then I'll dive right into the SDK and coding demos so most of this most of this webinar will be spent within the IDE and and showing you what to do with demo really but first we'll get started we'll we'll go over the architecture a little bit just to give you a high-level overview then I'll get into the live coding which is like I said gonna be the bulk of this presentation so firstly we're gonna discuss the relationships between signatories controllers and observers how to do multi-party workflows and and what do we mean by a demo transaction so that should be the bulk of it and lastly we'll we'll discuss next steps in particular if we have time I'll try to give you a little bit of a teaser for for dabble okay so let's get right into it okay so this is a this is a very high-level overview of the architecture that we'll be using for the hackathon so the the light blue cloud here is is dabble so that's our that's our cloud offering for for a demo enabled ledger if it will host demo contracts there which specify most of the rules of the game so we're hoping that the bulk of your hacking during the hackathon is going to be using demo to set up the relevant workflows which will be hosted on on that ledger talking to that directly are gonna be Python BOTS written in a language called dazzle yeah that's a that's quite a few acronyms starting with da but dazzle is a Python library that lets you lets you create effectively write lambdas which will react to creation and archival events on the ledger and it will let you respond directly by putting things back onto the ledger so this lets you build automations auto acceptors let's say or or small computations that that you can't do in demo 4 for a variety of reasons including for instance that demo contract must be deterministic so if you need to do anything asynchronously then then you'll need to build some sort of a bot so to go outside the bounds of the of the ledger of dabble you will need to connect using a REST API so you can and and it's it's a it's a it's a plain old standard secure REST API which means you can actually just embed JavaScript code in your in your website if you'd like to in addition to that we've built some tooling around converting the CDM into JSON and uploading that into the ledger directly and like I said we'll be getting into that in the in the next two webinars or so but for today we'll be focusing mostly on how to write demo contracts we won't be getting into any of this sort of details around the architecture and and how do we you know the details of the CDM this is this is more focused on demo itself so having said all that let's get into the SDK and and let's code I was thinking of doing a simple simple use case where a person buys a service and this service becomes fungible or non-functional based the terms and conditions of that service the idea is to to show you how signatories will work together and how controllers work together and how you make assets and liabilities using using standard demo features and functions okay so what I've done is I've gone into my shell here and I'm going to create a new project called let's say hackathon by the way if you haven't downloaded the SDK I highly encourage you to do so but it gives you it for the most part it gives you this demo command that lets you do a couple of things including visualize your code run an IDE with with a with a lightweight ledger inside and it's it's what it's the it's the main tool we use for for writing demo code so I've created a new project called hackathon and it'll usually prompt me by to say you know maybe I'm not on the latest version you can go ahead and download that if you if you like to so damned old new hackathon will create a new project for me called hackathon and to open that I'll type demos Cydia which will open for me Visual Studio code and immediately you get a small demo program out of the box that that you can use to to test to make sure your installations working you know your installations working when you can click on scenario results at the bottom here and you get something that looks like the result of a sequel query on the on the right okay but we're not going to be touching the main thing here I'll create my own module for for a paid service okay I'll go ahead and pin the version of Dan'l on the top there I'll call my module let's say paid service and and say we're okay as you as you know we do assume a little bit of familiarity with with demo but if that's not the case I think you can still follow along and catch up with you know reading and necessary tutorials and and then maybe re watching the video if you need to so what is a paid service exactly it's it's something which binds together a provider of that service to the beneficiary of a service this is gonna be the description of the service you know it's it's just gonna be a bit of text right now but in sort of more complicated cases it's this won't be text this will actually be let's say the entire definition of an interest rate swap let's say or or whatever the CDM will will describe so text is just unformatted you know it's an unformatted string of characters but demo lets you set up very sophisticated types that will provide like as the payload to your templates and we'll say that so who's the actual signatory on this contract it should be the beneficiary because actually no it should be the provider I bet it should be the provider because this service is just going to be the promise of the provider to to to do something for the sake of the beneficiary so the signatory keyword here means that the provider must do something he has the obligation he has the liability to do so he's liable for all of these things usually at the very base case it means that he has some sort of an obligation to perform off ledger in this case in this case you know provide let's say consulting services or something like that and just from an accounting standpoint think liability this is something you have to do it's something that it's gonna be upcoming that you have to perform on the flip side of that is being a controller so that's obviously the asset side so we'll say that the beneficiary is a is a controller which means he may do something it's it's an asset it's a it's a right it's a choice it's something that you get to do as a as a result of being labeled a controller so we'll say that the beneficiary can let's say transfer the service to somebody else making this thing completely fungible and one thing here if if you think this is going a little bit slow will will will pick up the complexity a little bit as we add some some of let's say non-standard dental features so this this will this can get quite complicated quickly so transferring the contract really means creating a version of this current contract archiving the previous one and changing one of the fields so we'll say I create this basically means create a copy of this with the beneficiary equaling the next beneficiary and I forgot to put in the argument here I see somebody's already spotting my syntax error all right I'm gonna have a see this is why I didn't major in English beneficiary there we go okay perfect okay this is this is working out well done guys in the in the chat for for picking this up then Effie she finish out every up beneficiary there we go but I misspelled it twice so that ought to count twice all right is everybody satisfied with this all right perfect well well done guys in the chat okay so what we've done here is we've granted the obligation to the provider to provide the service and we've granted the beneficiary the right to be able to transfer this service to to somebody else and we can already write a little test case on this so kind of one of the neat features of the SDK and I'll blow away the right last tab here is that I can create my own I can I can mock spin up a network and transact on it kind of from a like a God's eye view to to test my to test my templates immediately so let's say let's create a couple of parties here which has the effect of kind of spinning up a node in a DLT sense or creating a user and the non DLT sense but sylheti so we have one party whose name is Beth we have another one Manish and we're gonna create a service between them so we'll say that Manish is going to be the provider to service and he'll create a service agreement where he is the provider beneficiary is Beth and the the service is going to be something like I don't know consulting services okay great so and you can see the result of like what would happen on the ledger on the right hand side here so this is good and it already offers some protections rights because if if Beth tried to create this contract we got the red squiggle underline of deaf saying that our scenario failed and it the the ledger will will tell us exactly why and the reason is is that we're missing an authorization from Manish this usually means that you try to create a contract where one of the signatories never gave their consent and then that's the case here Manish never consented to this even though he is a signatory of this contract so this gives us some protection conversely Manish can't create this contract either we're you know Beth is the provider of its service same deal here Beth never give consent so this is this is not going to work now however so let's let's but but this this sort of has some problems already as well namely that let's say what if what if Beth doesn't want the service right what if there is some cost attached to this you know that look there's a there's a cost of okay Manish is creating the service where it's gonna cost a thousand dollars it's not right exactly that Manish can just put treat create this contract where where best has to pay him $2,000 or seemingly anyway now note that even even if the contract looks like this Beth is never a signatory on this so she can just say like look I never give my consent because I'm not a signatory on this thing so so this can so this this won't really hold her reliable here but nevertheless we want to we want to create a contract that does represent this type of service agreement and the way to do so is to create to make the beneficiary there we go I'm just gonna rely on autocomplete on on how to have to spell beneficiary so we're gonna make Beth a signatory on this contract as well so that way she needs to have given her consent to be put inside this position on the other hand when she does give consent then she'll be liable to to perform on this contract name II namely pay the payment Asia's fees okay however we get into we get into a problem here with the signatories because now Manish can't just create this contract okay and the reason is is the same as before Beth never gave her consent now Beth needs to give her consent to create this contract and and she's not given it yet okay well so can Beth create this contract and and of course not it's it's the same reason as before Manisha's the provider and he hasn't given given his permission so you'd think there'd be something like this where both of them give their sign-on at the same time simultaneously and and create this contract but actually actually if you think about it these scenarios are simulating what would happen in a distributed environment and which in which case you can't ever guarantee that somebody is going to give their gift consent at the same time what if what if Beth's give Beth gives her content but you know Manish Manish on plugs his computer and now now the ledger is in some sort of an inconsistent state where Beth's view of the world is different than Manisha's Manisha's is still from the time when he you know he hasn't seen this contract yet so therefore we we have to do something - to allow - to get the consent of both parties and we have to do so completely on ledger now one thing Manish could do is this he could make himself the beneficiary of the contract now and there you go this works however the problem is is that you know this doesn't mean anything he's both the asset and liability holder so he's going to provide consulting services to himself and pay himself like whoop-dee-doo but so what we must do is we have to create a workflow that that lets us transfer this service to another beneficiary oh and let's try one more thing here so suppose Manish creates this contract and then he also tries to transfer the contract to Beth directly that will say that Manish exercises his choice to transfer because remember now he's also the beneficiary of this so he gets to transfer and he'll specify the next beneficiary as Beth and surprise surprise it still fails because we have Beth never gave her consent to this either so there's just never any way that this contract is going to get created without best having to do something so let's give her the opportunity to do so so we'll write a another template which will represent an offer a service offer from the provider to Beth or to the beneficiary rather and the signatory on this is going to be the original service provider and the original service beneficiary and the reason is is that you want both original parties to be able to sign off on on the fact that this this transfer is going to to take place you you're representing the fact that if the next beneficiary accepts both parties both the original service provider and the original service beneficiary sign off on all of the consequences of that acceptance which in this case is going to be a service with the the next beneficiary so we'll say that the next beneficiary and accept the offer which will result in a new service and we'll say we'll create the service with the beneficiary being the next beneficiary okay so the meaning of this choice is that we create a copy of the original service contract except with one difference that the beneficiary is the next beneficiary and since the next beneficiary is a controller on this template he can give his consent to become a signatory on this service because beneficiary is a signatory and next beneficiary is a controller it means that this is this is the transfer of consent this is how an asset becomes a liability it's basically saying yes you know I've exercised my choice to take on the responsibility of becoming a beneficiary on the service contract I've obviously the liability there is going to be paying the cost of the of the service and of course the the implication here is that he can also reject the offer right it means that you know like you know the next beneficiary he doesn't want the offer and the way to the way to represent this is to say is to recreate the original service proposal what this means here is that if the if the next beneficiary rejects the offer then we simply recreate the original original service okay so so let's see that play oh you have to wire this up now so rather than this creating any sort and service we're gonna say this is going to create a new service offer and we will say that create service offer with service equals this along with the next beneficiary okay so now we have a bilateral contract here which ought to work so so our scenario just just works here but the current state of the ledger is that so monisha initially created the service where he is the beneficiary he submits the transfer and now there is a service offer on the ledger the original service having been archived so this replaces the original service and we create a new service offer with with all of the details that we want so you can see this is the original service and the next beneficiary is going to be Beth and of course will will do the happy pass on this one and Beth will accept accept the offer and at the end of that we have a we have a bilateral agreement between Manish and Beth - for Manish to provide consulting services at the cost of $1000 - Manish okay now one thing I didn't go over too much is that kind of the the payload of these templates you can see that the templates comprised of basically the parties involved in a transaction and a payload right and the payload right now is just a bit of text along with cost and currency however this is also where you can put in terms and conditions like maybe we don't want this we don't want this service to be transferable at all in which case we'll say something like you know do we want the service to be transferable and we'll assert before the before creating the the new contract to say expert that you know this thing is transferable which means if it's not transferable the whole thing will fail elegantly so we'll say let's say if Manish creates this thing to be not transferable then of course you know he won't even be able to to submit the original transfer to Beth so you can build up rather complicated terms and conditions here and in fact really that's what the CDM is all about it's specifying all of the different terms and conditions and specifying which workflow to take in in each you know with with the different asset classes so you you can yeah you can think generally think of the CDM as providing a very very rich payload for for these templates they provide effectively all of the the term sheets of of complex derivative products and I would say the the job of demo in these cases is to enforce those terms and conditions and make sure that the derivatives and the assets behave the way they should on legit okay so I make this true here okay next what I wanted to cover is the possibility of adding an intermediary to to the service something something like an agent basically baffan Manish don't want to deal with each other anymore they want to hire a third person to act as a as a go-between so at the end of it there's going to be two service contracts one between Manisha and the agent Manish will still continue to provide his consultancy services and Beth is still going to be liable to pay the eight but she's gonna be paying the agent so there will be a relationship between Manisha and the agent nobody a relationship between the agent and and Beth if you if you remember last year's hackathon this is actually the the Novation use case where a central counterparty steps in between two counterparties to take on both sides of the risk of an interest rate swap so we'll model this will model this out here okay so we want to say that the beneficiary should be able to designate an agent and we're not sure what this what this returns yet so I'll just stub it out here but we'll and and the same same rule applies here we we're going to be putting another party in an obligor position which means we need to give them the ability to to consent to that what we want to do is we want to represent that state where we've where we've offered this thing to the agent and he or she has not yet accepted so we'll do let's say we'll create an agent offer with the service pointing to the copy of the current contract and the agent being be the agent so of course will now need to create this agent offer template and think to yourself okay so who are the signatories on this thing it ought to be both the original provider and the original beneficiary simply because they have to be okay with whatever consequence arises from this template which could be either the agent rejecting the offer or not rejecting it okay so let's put in we're of course giving the right to the agent to accept or reject this thing you can accept the role which will result in what it will actually result in two different service offers so we're going to create two separate service contracts here where we say the first contract so service one is going to be between the the provider and the the agent so in that case the the beneficiary changes and the second service where the provider changes who is going to be the agent and we simply return a tuple containing those two services okay so so the way this workflow will work is that the original beneficiary can designate an agent which will create an agent offer the agent can then accept that and which will then create the two service agreements that we need and now there's an intermediary called the agent who's was going to be performing the both the role of the beneficiary and the provider in the two contracts okay so let's let's do this so so here I just get rid of the syntax error here so here Beth is the the beneficiary of the service so she's the one that gets to designate the agent there's a new agent on the CID with agent being a third party let's call him Georg okay so what do we have at the end of this we have an agent offer with with all of the terms as as before so Manish and Beth are in the original contract and we've offered this thing to the Georg as the agent and let's stick to the happy path here and we'll say that the to see IDs will be accepted by Georg so we can see the the ledger update in real time on the right here and after we've accepted this thing we can see that Manish and Georg so there's there's a relationship between Manish and Georg in this service contract and a separate contract between Georg and Beth so like I said this sort of harkens back to the Novation example from last year's their attack when one neat thing here is you can see who sees all of the the different contracts okay so in this case actually Beth Georg and Manish can see both all three contracts but there's a little bit of a nuance here which is that yes all three parties are aware of the consequences I should go back to the screen first yes all three parties are aware of all of the resulting contracts however not all three parties are actually stakeholders on those contract so for instance this agreement between Manisha and Georg is visible to Beth only because she was a stakeholder on the original contract and she knows all of the consequences that can result from that contract so she'll know that the only way that her you know the original contract on which she was a stakeholder can disappear is in X Y Z ways so she'll know exactly what the shape of the resultant contracts will look like however that is not a stakeholder on this which means she doesn't will not get notified if that contract is is archived so she'll know that it has existed at one point but she will not be notified of any changes that happened to that contract this is this is quite an important distinction here so yes sometimes contracts are disclosed to non stakeholders but even if that is the case they will not be notified of any future changes to those contracts okay [Music] so one thing I wanted to cover here is the the optional keyword because it trips up trips up quite a few people up what if on the original service agreement we can designate an optional agent it may be you know Beth knows going into the thing that this is going to be disintermediated or rather intermediated and she says okay you know I'm happy to do this contract but this is the agent that I'm going to work work through so what we might do is we might provide an optional party on the original service agreement to say looking that's that that's the designated agent that we want and you'll see optionals all over the CDM you know not every field is going to be necessary on the sepia so what we will enforce here is when we create the agent offer we want to assert that the agent is equal to the the original optional agent actually I'm going to change the name of this to opt agent in other words if the agent has been specified we want to make sure that the person we're designating is that agent otherwise we can designate any old agent so so one way to deal with this is to say if the use case statements within demo will say if if the optional agent is is an actual agent a then we'll we'll say we'll assert that the a is equal to the agent that we that we provided otherwise if it's not provided then we don't do anything at all okay so this way we say that you know if there's an optional agent we can go ahead and check to make sure that that's a that's actually the designated otherwise we're going to return nothing otherwise we do nothing so we'll say the optional agent is gonna be none so we don't we don't specify anybody up here but let's say we did I'm gonna put myself in the narrative here if we say that the designated agent is Georg everything is working as before however if we if we designate myself as the agent here we're going to get an error basically saying look you've designated an agent which was different than what you had then what you specified up front so now now this is now this is failing ok so this is all of the demo that I wanted to go through today I hope that gave you an idea of how to move obligations and rights around from different people ok I just got a note saying that I should talk about how disclosure works so let's see so let's let's go ahead and make this work again so we're back down to Georg okay and this is this is something I discussed a little bit earlier but the the reason the way disclosure works and the easiest way to visualize this is to look at the transaction tree so this is a let's call it more developer less user-friendly view of exactly the same details as before so you can see that we're going from transaction 0 all the way to transaction 4 and this model is the the five transactions that we've submitted in our scenario so there's a one to one between each submit to each transaction here and the way disclosure works generally is that the rule of thumb here is that if you're a stakeholder on a contract you will get to know all of the consequences of that contract however only the direct consequences so you may not know like for instance in in the case where Georg accepted his role as the agent and let's say let's say Beth transfers her contract to to me to levy will do the so Beth will transfer her contract who can't spell again to me oh it's the wrong contraction we will see that the the original service is still known to to all three parties but now the the service offer between myself and Beth Le'Veon Beth will be not known to to Manish so like I said on the original contract I'll just comment this out Manish was aware of the cause of the service contract between Georg and bass and the reason for that is because he was a stake holder on the contract which originated originated that consequence contract however he won't be notified for instance if that if that contract is is archived and that's what we see here so it'll be divulged to him but if he will not be a stakeholder meaning he won't be a prize if there's an archival okay so so that is all I wanted to cover for for this for this demo demo training now what I'll do next is a kind of give a teaser for for what's upcoming so there will be a separate training on dabble itself but I think you can already start playing around with it too to get an idea of how it works and and the idea is very simple actually so I'm gonna go ahead and go to project dabble and I'm going to to log in so I'll go ahead and log in with my my Google ID here and the idea is that I can very quickly upload a demo demo archive file and and have a working ledger you know within within minutes when I tried this last night it took about three minutes so I'll go ahead and run through that with you so here I've logged on to my works place I'm gonna create a new project let's call this hackathon and I'm going to create a new ledger let's call it and be very creative let's call it ledger okay so um now what's going on here is that there's an actual ledger being created on on our cloud offering you know we're setting up all of the rights for spinning up the nodes etc but in the meanwhile I'll go ahead and compile my my demo code so the the way to to compile compile demo is you have to go into your demo yeah mol file and and just basically point your your scenario to the demo module that you've created so this paid service test is pointing to this test scenario right here this is just so that the compiler picks up the the correct modules and then the prompt I just typed down will build which creates a dar file in this directory here so if you actually just cap this I'm gonna be terribly intrigued oh you know it's a very very interesting bytecode file so it's it's sort of the the same thing as a jar file or a dot class file in Java or is analogous to it'sit's importantly it's not actually Java bytecode it's it's it's our own own bytecode so then I can go ahead and upload this file I'll go pick up the actual hackathon file and you can see that it basically uploaded to to my workspace here ok and then I can go into my testing ledger alright we go and we can see what's what's there already i pre-baked something already to to make sure I can show something but the idea is you can quickly upload your your dart file and then you can kind of see it in action so you can create I've already created the parties here but you can add additional parties which has effectively the the which is effectively spinning up a note on behalf of that party and you can start adding contracts and exercising choices and so forth so as myself I'm going to create a service contract which is going to be provided by me let's say to Beth I don't know wash the car for a hundred bucks and we'll say that it is transferable and there's an optional agent let's say let's say gear works the optional agent I'm going to gonna go ahead and submit that and then you can start basically start playing around with the the contracts that get created here so there's there's one precooked here so you can you know transfer in by two agent etc so you can you can very quickly upload your dart file and and and play around okay so the next steps so there's two more hackathons upcoming ones on October 2 and it's the the river to to demo this is where we're going to get quite a bit into how the demo works with the CDM so the idea is to is to go through the connection between the CDM and demo itself the one following that on October 9th at the same time is to go through more of the architecture so this is going to be a lot about dabble dazzle the rest API and how to interact with with your your ledger and I think that's it so thank you very much for your time this this session has been recorded so we'll make that available to you and so so look out for an email from us and in the meanwhile I invite you to go ahead and start looking at these resources particularly demo calm and project dabble and like I said if you've got any questions contact us on our public slack channel there are five 2019 and or send us an email lastly if you need support on dable itself and I forgot to list this here but there is a public slack as well called demo driven da l - driven where you can get support for dabble okay thank you very much